v2.3.3.1 (2025.11.24)

- correct menu control handling bug
- enhance UI elements for improved user experience

.github/workflows/release.yml

@@ -30,16 +30,9 @@ jobs:
           zip -r "../../dist/RGSX_update_latest.zip" . \
             -x "logs/*" \
                "logs/**" \
-               "images/*" \
-               "images/**" \
-               "games/*" \
-               "games/**" \
-               "scripts/*" \
-               "scripts/**" \
                "__pycache__/*" \
                "__pycache__/**" \
                "*.pyc" \
-               "sources.json" \
                "*.log"
           
           cd ../..
@@ -52,16 +45,9 @@ jobs:
           zip -r "dist/RGSX_full_latest.zip" ports windows \
             -x "ports/RGSX/logs/*" \
                "ports/RGSX/logs/**" \
-               "ports/RGSX/images/*" \
-               "ports/RGSX/images/**" \
-               "ports/RGSX/games/*" \
-               "ports/RGSX/games/**" \
-               "ports/RGSX/scripts/*" \
-               "ports/RGSX/scripts/**" \
                "ports/RGSX/__pycache__/*" \
                "ports/RGSX/__pycache__/**" \
                "ports/RGSX/*.pyc" \
-               "ports/RGSX/sources.json" \
                "ports/RGSX/*.log" \
                "windows/logs/*" \
                "windows/*.xml" \
@@ -88,12 +74,12 @@ jobs:
             
             ## 📥 Automatic Installation (Only for batocera Knulli)
 
-            ### ON PC : 
+            ### ON PC , NUC, SteamDeck or any x86_64 based: 
             1. Open File Manager (F1) then "Applications" and launch xterm
             2. Use the command line `curl -L bit.ly/rgsx-install | sh`
             3. Launch RGSX from "Ports" menu
 
-            ### ON RASPBERRY/ARM SBC / HANDHELD : 
+            ### ON RASPBERRY/ ARM based SBC / HANDHELD : 
             1. Connect your device with SSH on a computer/smartphone connected to same network (ssh root@IPADDRESS , pass:linux)
             2. Use the command line `curl -L bit.ly/rgsx-install | sh`
             3. Launch RGSX from "Ports" menu            
@@ -111,17 +97,12 @@ jobs:
             3. Launch RGSX from system "Windows"
             
 
-            ## 📥 Manual Update (you shouldn't need to do this as RGSX updates automatically on each start)
-            
-            #### Batocera/Knulli
+            ## 📥 Manual Update (only if automatic doesn't work for some obcure reason)
+
+            #### Batocera/Knulli/Retrobat
             1. Download latest update : https://github.com/RetroGameSets/RGSX/releases/latest/download/RGSX_update_latest.zip
-            2. Extract only PORTS folder in `/userdata/roms/`
-            3. Launch RGSX from the Ports menu
-            
-            #### Retrobat
-            1. Download latest update : https://github.com/RetroGameSets/RGSX/releases/latest/download/RGSX_update_latest.zip
-            2. Extract all folders in your Retrobat\roms folder
-            3. Launch RGSX from system "Windows"
+            2. Extract zip content on  in `/userdata/roms/ports/RGSX`
+            3. Launch RGSX
             
             
             ### 📖 Documentation

ports/RGSX/__main__.py

@@ -22,7 +22,7 @@ from display import (
     init_display, draw_loading_screen, draw_error_screen, draw_platform_grid,
     draw_progress_screen, draw_controls, draw_virtual_keyboard,
     draw_extension_warning, draw_pause_menu, draw_controls_help, draw_game_list,
-        draw_display_menu,
+        draw_display_menu, draw_filter_menu_choice, draw_filter_advanced, draw_filter_priority_config,
     draw_history_list, draw_clear_history_dialog, draw_cancel_download_dialog,
     draw_confirm_dialog, draw_reload_games_data_dialog, draw_popup, draw_gradient,
     draw_toast, show_toast, THEME_COLORS
@@ -420,6 +420,21 @@ async def main():
     global current_music, music_files, music_folder, joystick
     logger.debug("Début main")
     
+    # Charger les filtres de jeux sauvegardés
+    try:
+        from game_filters import GameFilters
+        from rgsx_settings import load_game_filters
+        config.game_filter_obj = GameFilters()
+        filter_dict = load_game_filters()
+        if filter_dict:
+            config.game_filter_obj.load_from_dict(filter_dict)
+            if config.game_filter_obj.is_active():
+                config.filter_active = True
+                logger.info("Filtres de jeux chargés et actifs")
+    except Exception as e:
+        logger.error(f"Erreur lors du chargement des filtres: {e}")
+        config.game_filter_obj = None
+    
     # Démarrer le serveur web en arrière-plan
     start_web_server()
     
@@ -672,6 +687,11 @@ async def main():
                 "history_error_details",
                 "history_confirm_delete",
                 "history_extract_archive",
+                "text_file_viewer",  # Visualiseur de fichiers texte
+                # Menus filtrage avancé
+                "filter_menu_choice",
+                "filter_advanced",
+                "filter_priority_config",
             }
             if config.menu_state in SIMPLE_HANDLE_STATES:
                 action = handle_controls(event, sources, joystick, screen)
@@ -1070,6 +1090,12 @@ async def main():
             elif config.menu_state == "filter_platforms":
                 from display import draw_filter_platforms_menu
                 draw_filter_platforms_menu(screen)
+            elif config.menu_state == "filter_menu_choice":
+                draw_filter_menu_choice(screen)
+            elif config.menu_state == "filter_advanced":
+                draw_filter_advanced(screen)
+            elif config.menu_state == "filter_priority_config":
+                draw_filter_priority_config(screen)
             elif config.menu_state == "controls_help":
                 draw_controls_help(screen, config.previous_menu_state)
             elif config.menu_state == "history":
@@ -1090,6 +1116,9 @@ async def main():
             elif config.menu_state == "history_error_details":
                 from display import draw_history_error_details
                 draw_history_error_details(screen)
+            elif config.menu_state == "text_file_viewer":
+                from display import draw_text_file_viewer
+                draw_text_file_viewer(screen)
             elif config.menu_state == "history_confirm_delete":
                 from display import draw_history_confirm_delete
                 draw_history_confirm_delete(screen)

ports/RGSX/config.py

@@ -13,7 +13,7 @@ except Exception:
     pygame = None  # type: ignore
 
 # Version actuelle de l'application
-app_version = "2.3.2.6"
+app_version = "2.3.3.1"
 
 
 def get_application_root():
@@ -380,6 +380,11 @@ search_mode = False  # Indicateur si le mode recherche est actif
 search_query = ""  # Chaîne de recherche saisie par l'utilisateur
 filter_active = False  # Indicateur si un filtre est appliqué
 
+# Variables pour le filtrage avancé
+selected_filter_choice = 0  # Index dans le menu de choix de filtrage (recherche / avancé)
+selected_filter_option = 0  # Index dans le menu de filtrage avancé
+game_filter_obj = None  # Objet GameFilters pour le filtrage avancé
+
 # Gestion des états du menu
 needs_redraw = False  # Indicateur si l'écran doit être redessiné
 selected_option = 0  # Index de l'option sélectionnée dans le menu

ports/RGSX/controls.py

@@ -58,7 +58,13 @@ VALID_STATES = [
     "scraper",                  # écran du scraper avec métadonnées
     "history_error_details",    # détails de l'erreur
     "history_confirm_delete",   # confirmation suppression jeu
-    "history_extract_archive"   # extraction d'archive
+    "history_extract_archive",  # extraction d'archive
+    "text_file_viewer",         # visualiseur de fichiers texte
+    # Nouveaux menus filtrage avancé
+    "filter_menu_choice",       # menu de choix entre recherche et filtrage avancé
+    "filter_search",            # recherche par nom (existant, mais renommé)
+    "filter_advanced",          # filtrage avancé par région, etc.
+    "filter_priority_config",   # configuration priorité régions pour one-rom-per-game
 ]
 
 def validate_menu_state(state):
@@ -476,8 +482,15 @@ def handle_controls(event, sources, joystick, screen):
                 if config.platforms:
                     config.current_platform = config.selected_platform
                     config.games = load_games(config.platforms[config.current_platform])
-                    config.filtered_games = config.games
-                    config.filter_active = False
+                    
+                    # Apply saved filters automatically if any
+                    if config.game_filter_obj and config.game_filter_obj.is_active():
+                        config.filtered_games = config.game_filter_obj.apply_filters(config.games)
+                        config.filter_active = True
+                    else:
+                        config.filtered_games = config.games
+                        config.filter_active = False
+                    
                     config.current_game = 0
                     config.scroll_offset = 0
                     draw_validation_transition(screen, config.current_platform)
@@ -505,6 +518,8 @@ def handle_controls(event, sources, joystick, screen):
                 max_row = len(keyboard_layout) - 1
                 max_col = len(keyboard_layout[row]) - 1
                 if is_input_matched(event, "up"):
+                    if row == 0: # if you are in the first row and press UP jump to last row
+                        row = max_row + (1 if col <= 5 else 0)
                     if row > 0:
                         config.selected_key = (row - 1, min(col, len(keyboard_layout[row - 1]) - 1))
                         config.repeat_action = "up"
@@ -513,6 +528,8 @@ def handle_controls(event, sources, joystick, screen):
                         config.repeat_key = event.key if event.type == pygame.KEYDOWN else event.button if event.type == pygame.JOYBUTTONDOWN else (event.axis, 1 if event.value > 0 else -1) if event.type == pygame.JOYAXISMOTION else event.value
                         config.needs_redraw = True
                 elif is_input_matched(event, "down"):
+                    if (col <= 5 and row == max_row) or (col > 5 and row == max_row-1): # if you are in the last row and press DOWN jump to first row
+                        row = -1
                     if row < max_row:
                         config.selected_key = (row + 1, min(col, len(keyboard_layout[row + 1]) - 1))
                         config.repeat_action = "down"
@@ -521,6 +538,8 @@ def handle_controls(event, sources, joystick, screen):
                         config.repeat_key = event.key if event.type == pygame.KEYDOWN else event.button if event.type == pygame.JOYBUTTONDOWN else (event.axis, 1 if event.value > 0 else -1) if event.type == pygame.JOYAXISMOTION else event.value
                         config.needs_redraw = True
                 elif is_input_matched(event, "left"):
+                    if col == 0: # if you are in the first col and press LEFT jump to last col
+                        col = max_col + 1
                     if col > 0:
                         config.selected_key = (row, col - 1)
                         config.repeat_action = "left"
@@ -529,6 +548,8 @@ def handle_controls(event, sources, joystick, screen):
                         config.repeat_key = event.key if event.type == pygame.KEYDOWN else event.button if event.type == pygame.JOYBUTTONDOWN else (event.axis, 1 if event.value > 0 else -1) if event.type == pygame.JOYAXISMOTION else event.value
                         config.needs_redraw = True
                 elif is_input_matched(event, "right"):
+                    if col == max_col: # if you are in the last col and press RIGHT jump to first col
+                        col = -1
                     if col < max_col:
                         config.selected_key = (row, col + 1)
                         config.repeat_action = "right"
@@ -656,14 +677,12 @@ def handle_controls(event, sources, joystick, screen):
                                     event.value)
                     config.needs_redraw = True                    
                 elif is_input_matched(event, "filter"):
-                    config.search_mode = True
-                    config.search_query = ""
-                    config.filtered_games = config.games
-                    config.current_game = 0
-                    config.scroll_offset = 0
-                    config.selected_key = (0, 0)
+                    # Afficher le menu de choix entre recherche et filtrage avancé
+                    config.menu_state = "filter_menu_choice"
+                    config.selected_filter_choice = 0
+                    config.previous_menu_state = "game"
                     config.needs_redraw = True
-                    logger.debug("Entrée en mode recherche") 
+                    logger.debug("Ouverture du menu de filtrage") 
                 elif is_input_matched(event, "history"):
                     config.menu_state = "history"
                     config.needs_redraw = True
@@ -990,6 +1009,8 @@ def handle_controls(event, sources, joystick, screen):
                         ext = os.path.splitext(actual_filename)[1].lower()
                         if ext in ['.zip', '.rar']:
                             options.append("extract_archive")
+                        elif ext == '.txt':
+                            options.append("open_file")
                 elif status in ["Erreur", "Error", "Canceled"]:
                     options.append("error_info")
                     options.append("retry")
@@ -1032,6 +1053,30 @@ def handle_controls(event, sources, joystick, screen):
                         config.needs_redraw = True
                         logger.debug(f"Affichage du dossier de téléchargement pour {game_name}")
                         
+                    elif selected_option == "open_file":
+                        # Ouvrir le fichier texte
+                        if actual_path and os.path.exists(actual_path):
+                            try:
+                                with open(actual_path, 'r', encoding='utf-8', errors='replace') as f:
+                                    content = f.read()
+                                config.text_file_content = content
+                                config.text_file_name = actual_filename
+                                config.text_file_scroll_offset = 0
+                                config.previous_menu_state = "history_game_options"
+                                config.menu_state = "text_file_viewer"
+                                config.needs_redraw = True
+                                logger.debug(f"Ouverture du fichier texte: {actual_filename}")
+                            except Exception as e:
+                                logger.error(f"Erreur lors de l'ouverture du fichier texte: {e}")
+                                config.menu_state = "error"
+                                config.error_message = f"Erreur lors de l'ouverture du fichier: {str(e)}"
+                                config.needs_redraw = True
+                        else:
+                            logger.error(f"Fichier texte introuvable: {actual_path}")
+                            config.menu_state = "error"
+                            config.error_message = "Fichier introuvable"
+                            config.needs_redraw = True
+                        
                     elif selected_option == "extract_archive":
                         # L'option n'apparaît que si le fichier existe, pas besoin de re-vérifier
                         config.previous_menu_state = "history_game_options"
@@ -1183,6 +1228,128 @@ def handle_controls(event, sources, joystick, screen):
                 config.needs_redraw = True
 
         # Affichage détails erreur
+        # Visualiseur de fichiers texte
+        elif config.menu_state == "text_file_viewer":
+            content = getattr(config, 'text_file_content', '')
+            if content:
+                lines = content.split('\n')
+                line_height = config.small_font.get_height() + 2
+                
+                # Calculer le nombre de lignes visibles (approximation)
+                controls_y = config.screen_height - int(config.screen_height * 0.037)
+                margin = 40
+                header_height = 60
+                content_area_height = controls_y - 2 * margin - 10 - header_height - 20
+                visible_lines = int(content_area_height / line_height)
+                
+                scroll_offset = getattr(config, 'text_file_scroll_offset', 0)
+                max_scroll = max(0, len(lines) - visible_lines)
+                
+                if is_input_matched(event, "up"):
+                    config.text_file_scroll_offset = max(0, scroll_offset - 1)
+                    update_key_state("up", True, event.type, event.key if event.type == pygame.KEYDOWN else 
+                                    event.button if event.type == pygame.JOYBUTTONDOWN else 
+                                    (event.axis, event.value) if event.type == pygame.JOYAXISMOTION else 
+                                    event.value)
+                    config.needs_redraw = True
+                elif is_input_matched(event, "down"):
+                    config.text_file_scroll_offset = min(max_scroll, scroll_offset + 1)
+                    update_key_state("down", True, event.type, event.key if event.type == pygame.KEYDOWN else 
+                                    event.button if event.type == pygame.JOYBUTTONDOWN else 
+                                    (event.axis, event.value) if event.type == pygame.JOYAXISMOTION else 
+                                    event.value)
+                    config.needs_redraw = True
+                elif is_input_matched(event, "page_up"):
+                    config.text_file_scroll_offset = max(0, scroll_offset - visible_lines)
+                    update_key_state("page_up", True, event.type, event.key if event.type == pygame.KEYDOWN else 
+                                    event.button if event.type == pygame.JOYBUTTONDOWN else 
+                                    (event.axis, event.value) if event.type == pygame.JOYAXISMOTION else 
+                                    event.value)
+                    config.needs_redraw = True
+                elif is_input_matched(event, "page_down"):
+                    config.text_file_scroll_offset = min(max_scroll, scroll_offset + visible_lines)
+                    update_key_state("page_down", True, event.type, event.key if event.type == pygame.KEYDOWN else 
+                                    event.button if event.type == pygame.JOYBUTTONDOWN else 
+                                    (event.axis, event.value) if event.type == pygame.JOYAXISMOTION else 
+                                    event.value)
+                    config.needs_redraw = True
+                elif is_input_matched(event, "cancel") or is_input_matched(event, "confirm"):
+                    config.menu_state = validate_menu_state(config.previous_menu_state)
+                    config.needs_redraw = True
+            else:
+                # Si pas de contenu, retourner au menu précédent
+                if is_input_matched(event, "cancel") or is_input_matched(event, "confirm"):
+                    config.menu_state = validate_menu_state(config.previous_menu_state)
+                    config.needs_redraw = True
+
+        # Visualiseur de fichiers texte
+        elif config.menu_state == "text_file_viewer":
+            content = getattr(config, 'text_file_content', '')
+            if content:
+                from utils import wrap_text
+                
+                # Calculer les dimensions
+                controls_y = config.screen_height - int(config.screen_height * 0.037)
+                margin = 40
+                header_height = 60
+                rect_width = config.screen_width - 2 * margin
+                content_area_height = controls_y - 2 * margin - 10 - header_height - 20
+                max_width = rect_width - 60
+                
+                # Diviser le contenu en lignes et appliquer le word wrap
+                original_lines = content.split('\n')
+                wrapped_lines = []
+                
+                for original_line in original_lines:
+                    if original_line.strip():  # Si la ligne n'est pas vide
+                        wrapped = wrap_text(original_line, config.small_font, max_width)
+                        wrapped_lines.extend(wrapped)
+                    else:  # Ligne vide
+                        wrapped_lines.append('')
+                
+                line_height = config.small_font.get_height() + 2
+                visible_lines = int(content_area_height / line_height)
+                
+                scroll_offset = getattr(config, 'text_file_scroll_offset', 0)
+                max_scroll = max(0, len(wrapped_lines) - visible_lines)
+                
+                if is_input_matched(event, "up"):
+                    config.text_file_scroll_offset = max(0, scroll_offset - 1)
+                    update_key_state("up", True, event.type, event.key if event.type == pygame.KEYDOWN else 
+                                    event.button if event.type == pygame.JOYBUTTONDOWN else 
+                                    (event.axis, event.value) if event.type == pygame.JOYAXISMOTION else 
+                                    event.value)
+                    config.needs_redraw = True
+                elif is_input_matched(event, "down"):
+                    config.text_file_scroll_offset = min(max_scroll, scroll_offset + 1)
+                    update_key_state("down", True, event.type, event.key if event.type == pygame.KEYDOWN else 
+                                    event.button if event.type == pygame.JOYBUTTONDOWN else 
+                                    (event.axis, event.value) if event.type == pygame.JOYAXISMOTION else 
+                                    event.value)
+                    config.needs_redraw = True
+                elif is_input_matched(event, "page_up"):
+                    config.text_file_scroll_offset = max(0, scroll_offset - visible_lines)
+                    update_key_state("page_up", True, event.type, event.key if event.type == pygame.KEYDOWN else 
+                                    event.button if event.type == pygame.JOYBUTTONDOWN else 
+                                    (event.axis, event.value) if event.type == pygame.JOYAXISMOTION else 
+                                    event.value)
+                    config.needs_redraw = True
+                elif is_input_matched(event, "page_down"):
+                    config.text_file_scroll_offset = min(max_scroll, scroll_offset + visible_lines)
+                    update_key_state("page_down", True, event.type, event.key if event.type == pygame.KEYDOWN else 
+                                    event.button if event.type == pygame.JOYBUTTONDOWN else 
+                                    (event.axis, event.value) if event.type == pygame.JOYAXISMOTION else 
+                                    event.value)
+                    config.needs_redraw = True
+                elif is_input_matched(event, "cancel") or is_input_matched(event, "confirm"):
+                    config.menu_state = validate_menu_state(config.previous_menu_state)
+                    config.needs_redraw = True
+            else:
+                # Si pas de contenu, retourner au menu précédent
+                if is_input_matched(event, "cancel") or is_input_matched(event, "confirm"):
+                    config.menu_state = validate_menu_state(config.previous_menu_state)
+                    config.needs_redraw = True
+
         elif config.menu_state == "history_error_details":
             if is_input_matched(event, "confirm") or is_input_matched(event, "cancel"):
                 config.menu_state = validate_menu_state(config.previous_menu_state)
@@ -1315,8 +1482,15 @@ def handle_controls(event, sources, joystick, screen):
 
         # Confirmation quitter
         elif config.menu_state == "confirm_exit":
-            if is_input_matched(event, "confirm"):
-                if config.confirm_selection == 1:
+            # Sous-menu Quit: 0=Quit RGSX, 1=Restart RGSX, 2=Back
+            if is_input_matched(event, "up"):
+                config.confirm_selection = max(0, config.confirm_selection - 1)
+                config.needs_redraw = True
+            elif is_input_matched(event, "down"):
+                config.confirm_selection = min(2, config.confirm_selection + 1)
+                config.needs_redraw = True
+            elif is_input_matched(event, "confirm"):
+                if config.confirm_selection == 0:  # Quit RGSX
                     # Mark all in-progress downloads as canceled in history
                     try:
                         for entry in getattr(config, 'history', []) or []:
@@ -1328,7 +1502,9 @@ def handle_controls(event, sources, joystick, screen):
                     except Exception:
                         pass
                     return "quit"
-                else:
+                elif config.confirm_selection == 1:  # Restart RGSX
+                    restart_application(2000)
+                elif config.confirm_selection == 2:  # Back
                     # Retour à l'état capturé (confirm_exit_origin) sinon previous_menu_state sinon platform
                     target = getattr(config, 'confirm_exit_origin', getattr(config, 'previous_menu_state', 'platform'))
                     config.menu_state = validate_menu_state(target)
@@ -1338,11 +1514,18 @@ def handle_controls(event, sources, joystick, screen):
                         except Exception:
                             pass
                     config.needs_redraw = True
-                    logger.debug(f"Retour à {config.menu_state} depuis confirm_exit (annulation)")
-            elif is_input_matched(event, "left") or is_input_matched(event, "right"):
-                config.confirm_selection = 1 - config.confirm_selection
+                    logger.debug(f"Retour à {config.menu_state} depuis confirm_exit (back)")
+            elif is_input_matched(event, "cancel"):
+                # Retour à l'état capturé
+                target = getattr(config, 'confirm_exit_origin', getattr(config, 'previous_menu_state', 'platform'))
+                config.menu_state = validate_menu_state(target)
+                if hasattr(config, 'confirm_exit_origin'):
+                    try:
+                        delattr(config, 'confirm_exit_origin')
+                    except Exception:
+                        pass
                 config.needs_redraw = True
-                #logger.debug(f"Changement sélection confirm_exit: {config.confirm_selection}")
+                logger.debug(f"Retour à {config.menu_state} depuis confirm_exit (cancel)")
 
         # Menu pause
         elif config.menu_state == "pause_menu":
@@ -1362,38 +1545,36 @@ def handle_controls(event, sources, joystick, screen):
                 config.selected_option = min(total - 1, config.selected_option + 1)
                 config.needs_redraw = True
             elif is_input_matched(event, "confirm"):
-                if config.selected_option == 0:  # Language selector direct
+                if config.selected_option == 0:  # Games submenu
+                    config.menu_state = "pause_games_menu"
+                    if not hasattr(config, 'pause_games_selection'):
+                        config.pause_games_selection = 0
+                    config.last_state_change_time = pygame.time.get_ticks()
+                    config.needs_redraw = True
+                elif config.selected_option == 1:  # Language selector direct
                     config.menu_state = "language_select"
                     config.previous_menu_state = "pause_menu"
                     config.last_state_change_time = pygame.time.get_ticks()
                     config.needs_redraw = True
-                elif config.selected_option == 1:  # Controls submenu
+                elif config.selected_option == 2:  # Controls submenu
                     config.menu_state = "pause_controls_menu"
                     if not hasattr(config, 'pause_controls_selection'):
                         config.pause_controls_selection = 0
                     config.last_state_change_time = pygame.time.get_ticks()
                     config.needs_redraw = True
-                elif config.selected_option == 2:  # Display submenu
+                elif config.selected_option == 3:  # Display submenu
                     config.menu_state = "pause_display_menu"
                     if not hasattr(config, 'pause_display_selection'):
                         config.pause_display_selection = 0
                     config.last_state_change_time = pygame.time.get_ticks()
                     config.needs_redraw = True
-                elif config.selected_option == 3:  # Games submenu
-                    config.menu_state = "pause_games_menu"
-                    if not hasattr(config, 'pause_games_selection'):
-                        config.pause_games_selection = 0
-                    config.last_state_change_time = pygame.time.get_ticks()
-                    config.needs_redraw = True
                 elif config.selected_option == 4:  # Settings submenu
                     config.menu_state = "pause_settings_menu"
                     if not hasattr(config, 'pause_settings_selection'):
                         config.pause_settings_selection = 0
                     config.last_state_change_time = pygame.time.get_ticks()
                     config.needs_redraw = True
-                elif config.selected_option == 5:  # Restart
-                    restart_application(2000)
-                elif config.selected_option == 6:  # Support
+                elif config.selected_option == 5:  # Support
                     success, message, zip_path = generate_support_zip()
                     if success:
                         config.support_zip_path = zip_path
@@ -1404,7 +1585,7 @@ def handle_controls(event, sources, joystick, screen):
                     config.menu_state = "support_dialog"
                     config.last_state_change_time = pygame.time.get_ticks()
                     config.needs_redraw = True
-                elif config.selected_option == 7:  # Quit
+                elif config.selected_option == 6:  # Quit submenu
                     # Capturer l'origine pause_menu pour retour si annulation
                     config.confirm_exit_origin = "pause_menu"
                     config.previous_menu_state = validate_menu_state(config.previous_menu_state)
@@ -1569,7 +1750,7 @@ def handle_controls(event, sources, joystick, screen):
         # Sous-menu Games
         elif config.menu_state == "pause_games_menu":
             sel = getattr(config, 'pause_games_selection', 0)
-            total = 7  # history, source, redownload, unsupported, hide premium, filter, back
+            total = 7  # update cache, history, source, unsupported, hide premium, filter, back
             if is_input_matched(event, "up"):
                 config.pause_games_selection = (sel - 1) % total
                 config.needs_redraw = True
@@ -1577,14 +1758,19 @@ def handle_controls(event, sources, joystick, screen):
                 config.pause_games_selection = (sel + 1) % total
                 config.needs_redraw = True
             elif is_input_matched(event, "confirm") or is_input_matched(event, "left") or is_input_matched(event, "right"):
-                if sel == 0 and is_input_matched(event, "confirm"):  # history
+                if sel == 0 and is_input_matched(event, "confirm"):  # update cache
+                    config.previous_menu_state = "pause_games_menu"
+                    config.menu_state = "reload_games_data"
+                    config.redownload_confirm_selection = 0
+                    config.needs_redraw = True
+                elif sel == 1 and is_input_matched(event, "confirm"):  # history
                     config.history = load_history()
                     config.current_history_item = 0
                     config.history_scroll_offset = 0
                     config.previous_menu_state = "pause_games_menu"
                     config.menu_state = "history"
                     config.needs_redraw = True
-                elif sel == 1 and (is_input_matched(event, "confirm") or is_input_matched(event, "left") or is_input_matched(event, "right")):
+                elif sel == 2 and (is_input_matched(event, "confirm") or is_input_matched(event, "left") or is_input_matched(event, "right")):  # source mode
                     try:
                         current_mode = get_sources_mode()
                         new_mode = set_sources_mode('custom' if current_mode == 'rgsx' else 'rgsx')
@@ -1599,11 +1785,6 @@ def handle_controls(event, sources, joystick, screen):
                         logger.info(f"Changement du mode des sources vers {new_mode}")
                     except Exception as e:
                         logger.error(f"Erreur changement mode sources: {e}")
-                elif sel == 2 and is_input_matched(event, "confirm"):  # redownload cache
-                    config.previous_menu_state = "pause_games_menu"
-                    config.menu_state = "reload_games_data"
-                    config.redownload_confirm_selection = 0
-                    config.needs_redraw = True
                 elif sel == 3 and (is_input_matched(event, "confirm") or is_input_matched(event, "left") or is_input_matched(event, "right")):  # unsupported toggle
                     try:
                         current = get_show_unsupported_platforms()
@@ -1642,11 +1823,19 @@ def handle_controls(event, sources, joystick, screen):
         elif config.menu_state == "pause_settings_menu":
             sel = getattr(config, 'pause_settings_selection', 0)
             # Calculer le nombre total d'options selon le système
-            total = 4  # music, symlink, api keys, back
+            # Liste des options : music, symlink, [web_service], [custom_dns], api keys, back
+            total = 4  # music, symlink, api keys, back (Windows)
             web_service_index = -1
+            custom_dns_index = -1
+            api_keys_index = 2
+            back_index = 3
+            
             if config.OPERATING_SYSTEM == "Linux":
-                total = 5  # music, symlink, web_service, api keys, back
+                total = 6  # music, symlink, web_service, custom_dns, api keys, back
                 web_service_index = 2
+                custom_dns_index = 3
+                api_keys_index = 4
+                back_index = 5
             
             if is_input_matched(event, "up"):
                 config.pause_settings_selection = (sel - 1) % total
@@ -1695,12 +1884,31 @@ def handle_controls(event, sources, joystick, screen):
                         else:
                             logger.error(f"Erreur toggle service web: {message}")
                     threading.Thread(target=toggle_service, daemon=True).start()
-                # Option API Keys (index varie selon Linux ou pas)
-                elif sel == (web_service_index + 1 if web_service_index >= 0 else 2) and is_input_matched(event, "confirm"):
+                # Option 3: Custom DNS toggle (seulement si Linux)
+                elif sel == custom_dns_index and custom_dns_index >= 0 and (is_input_matched(event, "confirm") or is_input_matched(event, "left") or is_input_matched(event, "right")):
+                    from utils import check_custom_dns_status, toggle_custom_dns_at_boot
+                    current_status = check_custom_dns_status()
+                    # Afficher un message de chargement
+                    config.popup_message = _("settings_custom_dns_enabling") if not current_status else _("settings_custom_dns_disabling")
+                    config.popup_timer = 1000
+                    config.needs_redraw = True
+                    # Exécuter en thread pour ne pas bloquer l'UI
+                    def toggle_dns():
+                        success, message = toggle_custom_dns_at_boot(not current_status)
+                        config.popup_message = message
+                        config.popup_timer = 5000 if success else 7000
+                        config.needs_redraw = True
+                        if success:
+                            logger.info(f"Custom DNS {'activé' if not current_status else 'désactivé'} au démarrage")
+                        else:
+                            logger.error(f"Erreur toggle custom DNS: {message}")
+                    threading.Thread(target=toggle_dns, daemon=True).start()
+                # Option API Keys
+                elif sel == api_keys_index and is_input_matched(event, "confirm"):
                     config.menu_state = "pause_api_keys_status"
                     config.needs_redraw = True
                 # Option Back (dernière option)
-                elif sel == (total - 1) and is_input_matched(event, "confirm"):
+                elif sel == back_index and is_input_matched(event, "confirm"):
                     config.menu_state = "pause_menu"
                     config.last_state_change_time = pygame.time.get_ticks()
                     config.needs_redraw = True
@@ -1919,6 +2127,261 @@ def handle_controls(event, sources, joystick, screen):
                 config.needs_redraw = True
                 logger.debug("Annulation de la sélection de langue, retour au menu pause")
 
+        # Menu de choix filtrage
+        elif config.menu_state == "filter_menu_choice":
+            if is_input_matched(event, "up"):
+                config.selected_filter_choice = (config.selected_filter_choice - 1) % 2
+                config.needs_redraw = True
+            elif is_input_matched(event, "down"):
+                config.selected_filter_choice = (config.selected_filter_choice + 1) % 2
+                config.needs_redraw = True
+            elif is_input_matched(event, "confirm"):
+                if config.selected_filter_choice == 0:
+                    # Recherche par nom (mode existant)
+                    config.search_mode = True
+                    config.search_query = ""
+                    config.filtered_games = config.games
+                    config.current_game = 0
+                    config.scroll_offset = 0
+                    config.selected_key = (0, 0)
+                    config.menu_state = "game"
+                    config.needs_redraw = True
+                    logger.debug("Entrée en mode recherche par nom")
+                else:
+                    # Filtrage avancé
+                    from game_filters import GameFilters
+                    from rgsx_settings import load_game_filters
+                    
+                    # Initialiser le filtre
+                    if not hasattr(config, 'game_filter_obj'):
+                        config.game_filter_obj = GameFilters()
+                        filter_dict = load_game_filters()
+                        if filter_dict:
+                            config.game_filter_obj.load_from_dict(filter_dict)
+                    
+                    config.menu_state = "filter_advanced"
+                    config.selected_filter_option = 0
+                    config.needs_redraw = True
+                    logger.debug("Entrée en filtrage avancé")
+            elif is_input_matched(event, "cancel"):
+                config.menu_state = "game"
+                config.needs_redraw = True
+                logger.debug("Retour à la liste des jeux")
+
+        # Filtrage avancé
+        elif config.menu_state == "filter_advanced":
+            from game_filters import GameFilters
+            from rgsx_settings import save_game_filters
+            
+            # Initialiser le filtre si nécessaire
+            if not hasattr(config, 'game_filter_obj'):
+                config.game_filter_obj = GameFilters()
+                from rgsx_settings import load_game_filters
+                filter_dict = load_game_filters()
+                if filter_dict:
+                    config.game_filter_obj.load_from_dict(filter_dict)
+            
+            # Construire la liste linéaire des éléments sélectionnables (pour simplifier l'indexation)
+            # Régions individuelles
+            num_regions = len(GameFilters.REGIONS)
+            # Options toggle/button
+            num_other_options = 3  # hide_non_release, one_rom_per_game, priority_config
+            # Boutons en bas
+            num_buttons = 3  # apply, reset, back
+            
+            total_items = num_regions + num_other_options + num_buttons
+            
+            if is_input_matched(event, "up"):
+                # Navigation verticale dans la grille ou entre sections
+                if config.selected_filter_option < num_regions:
+                    # Dans la grille des régions (3 colonnes)
+                    if config.selected_filter_option >= 3:
+                        # Monter d'une ligne
+                        config.selected_filter_option -= 3
+                    else:
+                        # Déjà en haut, aller aux boutons
+                        config.selected_filter_option = total_items - 2  # Bouton du milieu (reset)
+                else:
+                    # Dans les options ou boutons, monter normalement
+                    config.selected_filter_option = (config.selected_filter_option - 1) % total_items
+                
+                config.needs_redraw = True
+                update_key_state("up", True, event.type, event.key if event.type == pygame.KEYDOWN else 
+                                event.button if event.type == pygame.JOYBUTTONDOWN else 
+                                (event.axis, event.value) if event.type == pygame.JOYAXISMOTION else 
+                                event.value)
+            
+            elif is_input_matched(event, "down"):
+                # Navigation verticale
+                if config.selected_filter_option < num_regions:
+                    # Dans la grille des régions
+                    if config.selected_filter_option + 3 < num_regions:
+                        # Descendre d'une ligne
+                        config.selected_filter_option += 3
+                    else:
+                        # Aller aux autres options
+                        config.selected_filter_option = num_regions
+                else:
+                    # Dans les options ou boutons, descendre normalement
+                    config.selected_filter_option = (config.selected_filter_option + 1) % total_items
+                
+                config.needs_redraw = True
+                update_key_state("down", True, event.type, event.key if event.type == pygame.KEYDOWN else 
+                                event.button if event.type == pygame.JOYBUTTONDOWN else 
+                                (event.axis, event.value) if event.type == pygame.JOYAXISMOTION else 
+                                event.value)
+            
+            elif is_input_matched(event, "left"):
+                # Navigation horizontale
+                if config.selected_filter_option < num_regions:
+                    # Dans la grille des régions
+                    if config.selected_filter_option % 3 > 0:
+                        config.selected_filter_option -= 1
+                    config.needs_redraw = True
+                elif config.selected_filter_option >= num_regions + num_other_options:
+                    # Dans les boutons en bas
+                    button_idx = config.selected_filter_option - (num_regions + num_other_options)
+                    button_idx = (button_idx - 1) % num_buttons
+                    config.selected_filter_option = num_regions + num_other_options + button_idx
+                    config.needs_redraw = True
+            
+            elif is_input_matched(event, "right"):
+                # Navigation horizontale
+                if config.selected_filter_option < num_regions:
+                    # Dans la grille des régions
+                    if config.selected_filter_option % 3 < 2 and config.selected_filter_option + 1 < num_regions:
+                        config.selected_filter_option += 1
+                    config.needs_redraw = True
+                elif config.selected_filter_option >= num_regions + num_other_options:
+                    # Dans les boutons en bas
+                    button_idx = config.selected_filter_option - (num_regions + num_other_options)
+                    button_idx = (button_idx + 1) % num_buttons
+                    config.selected_filter_option = num_regions + num_other_options + button_idx
+                    config.needs_redraw = True
+            
+            elif is_input_matched(event, "confirm"):
+                # Déterminer quel élément a été sélectionné
+                if config.selected_filter_option < num_regions:
+                    # C'est une région
+                    region = GameFilters.REGIONS[config.selected_filter_option]
+                    current_state = config.game_filter_obj.region_filters.get(region, 'include')
+                    if current_state == 'include':
+                        config.game_filter_obj.region_filters[region] = 'exclude'
+                    else:
+                        config.game_filter_obj.region_filters[region] = 'include'
+                    config.needs_redraw = True
+                    logger.debug(f"Filtre région {region} modifié: {config.game_filter_obj.region_filters[region]}")
+                
+                elif config.selected_filter_option < num_regions + num_other_options:
+                    # C'est une autre option
+                    option_idx = config.selected_filter_option - num_regions
+                    if option_idx == 0:
+                        # hide_non_release
+                        config.game_filter_obj.hide_non_release = not config.game_filter_obj.hide_non_release
+                        config.needs_redraw = True
+                        logger.debug("Toggle hide_non_release modifié")
+                    elif option_idx == 1:
+                        # one_rom_per_game
+                        config.game_filter_obj.one_rom_per_game = not config.game_filter_obj.one_rom_per_game
+                        config.needs_redraw = True
+                        logger.debug("Toggle one_rom_per_game modifié")
+                    elif option_idx == 2:
+                        # priority_config
+                        config.menu_state = "filter_priority_config"
+                        config.selected_priority_index = 0
+                        config.needs_redraw = True
+                        logger.debug("Ouverture configuration priorité régions")
+                
+                else:
+                    # C'est un bouton
+                    button_idx = config.selected_filter_option - (num_regions + num_other_options)
+                    if button_idx == 0:
+                        # Apply
+                        save_game_filters(config.game_filter_obj.to_dict())
+                        
+                        # Appliquer aux jeux actuels
+                        if config.game_filter_obj.is_active():
+                            config.filtered_games = config.game_filter_obj.apply_filters(config.games)
+                            config.filter_active = True
+                        else:
+                            config.filtered_games = config.games
+                            config.filter_active = False
+                        
+                        config.current_game = 0
+                        config.scroll_offset = 0
+                        config.menu_state = "game"
+                        config.needs_redraw = True
+                        logger.debug("Filtres appliqués")
+                    
+                    elif button_idx == 1:
+                        # Reset
+                        config.game_filter_obj.reset()
+                        save_game_filters(config.game_filter_obj.to_dict())
+                        config.filtered_games = config.games
+                        config.filter_active = False
+                        config.needs_redraw = True
+                        logger.debug("Filtres réinitialisés")
+                    
+                    elif button_idx == 2:
+                        # Back
+                        config.menu_state = "game"
+                        config.needs_redraw = True
+                        logger.debug("Retour sans appliquer les filtres")
+            
+            elif is_input_matched(event, "cancel"):
+                config.menu_state = "game"
+                config.needs_redraw = True
+                logger.debug("Annulation du filtrage avancé")
+
+        # Configuration priorité régions
+        elif config.menu_state == "filter_priority_config":
+            from game_filters import GameFilters
+            from rgsx_settings import save_game_filters
+            
+            if not hasattr(config, 'game_filter_obj'):
+                config.game_filter_obj = GameFilters()
+            
+            priority_list = config.game_filter_obj.region_priority
+            total_items = len(priority_list) + 1  # +1 pour le bouton Back
+            
+            if not hasattr(config, 'selected_priority_index'):
+                config.selected_priority_index = 0
+            
+            if is_input_matched(event, "up"):
+                config.selected_priority_index = (config.selected_priority_index - 1) % total_items
+                config.needs_redraw = True
+            elif is_input_matched(event, "down"):
+                config.selected_priority_index = (config.selected_priority_index + 1) % total_items
+                config.needs_redraw = True
+            elif is_input_matched(event, "confirm"):
+                if config.selected_priority_index >= len(priority_list):
+                    # Bouton Back : retour au menu filtrage avancé
+                    save_game_filters(config.game_filter_obj.to_dict())
+                    config.menu_state = "filter_advanced"
+                    config.needs_redraw = True
+                    logger.debug("Retour au filtrage avancé")
+            elif is_input_matched(event, "left") and config.selected_priority_index < len(priority_list):
+                # Monter la région dans la priorité
+                idx = config.selected_priority_index
+                if idx > 0:
+                    priority_list[idx], priority_list[idx-1] = priority_list[idx-1], priority_list[idx]
+                    config.selected_priority_index = idx - 1
+                    config.needs_redraw = True
+                    logger.debug(f"Priorité modifiée: {priority_list}")
+            elif is_input_matched(event, "right") and config.selected_priority_index < len(priority_list):
+                # Descendre la région dans la priorité
+                idx = config.selected_priority_index
+                if idx < len(priority_list) - 1:
+                    priority_list[idx], priority_list[idx+1] = priority_list[idx+1], priority_list[idx]
+                    config.selected_priority_index = idx + 1
+                    config.needs_redraw = True
+                    logger.debug(f"Priorité modifiée: {priority_list}")
+            elif is_input_matched(event, "cancel"):
+                # Retour sans sauvegarder
+                config.menu_state = "filter_advanced"
+                config.needs_redraw = True
+                logger.debug("Annulation configuration priorité")
+
     # Menu filtre plateformes
         elif config.menu_state == "filter_platforms":
             total_items = len(config.filter_platforms_selection)
@@ -2351,4 +2814,4 @@ def get_emergency_controls():
         # manette basique
         "confirm_joy": {"type": "button", "button": 0},
         "cancel_joy": {"type": "button", "button": 1},
-    }
+    }

ports/RGSX/game_filters.py

@@ -0,0 +1,237 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Module de filtrage des jeux pour RGSX
+Partagé entre l'interface graphique et l'interface web
+"""
+
+import re
+import logging
+from typing import List, Tuple, Dict, Any
+
+logger = logging.getLogger(__name__)
+
+
+class GameFilters:
+    """Classe pour gérer les filtres de jeux"""
+    
+    # Régions disponibles
+    REGIONS = ['USA', 'Canada', 'Europe', 'France', 'Germany', 'Japan', 'Korea', 'World', 'Other']
+    
+    def __init__(self):
+        # Initialiser toutes les régions en mode 'include' par défaut
+        self.region_filters = {region: 'include' for region in self.REGIONS}
+        self.hide_non_release = False
+        self.one_rom_per_game = False
+        self.regex_mode = False
+        self.region_priority = ['USA', 'Canada', 'World', 'Europe', 'Japan', 'Other']
+    
+    def load_from_dict(self, filter_dict: Dict[str, Any]):
+        """Charge les filtres depuis un dictionnaire (depuis settings)"""
+        loaded_region_filters = filter_dict.get('region_filters', {})
+        # Initialiser toutes les régions en 'include' par défaut, puis appliquer celles chargées
+        self.region_filters = {region: 'include' for region in self.REGIONS}
+        self.region_filters.update(loaded_region_filters)
+        
+        self.hide_non_release = filter_dict.get('hide_non_release', False)
+        self.one_rom_per_game = filter_dict.get('one_rom_per_game', False)
+        self.regex_mode = filter_dict.get('regex_mode', False)
+        self.region_priority = filter_dict.get('region_priority', 
+            ['USA', 'Canada', 'World', 'Europe', 'Japan', 'Other'])
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convertit les filtres en dictionnaire (pour sauvegarder dans settings)"""
+        return {
+            'region_filters': self.region_filters,
+            'hide_non_release': self.hide_non_release,
+            'one_rom_per_game': self.one_rom_per_game,
+            'regex_mode': self.regex_mode,
+            'region_priority': self.region_priority
+        }
+    
+    def is_active(self) -> bool:
+        """Vérifie si des filtres sont actifs (au moins une région en exclude ou options activées)"""
+        has_exclude = any(state == 'exclude' for state in self.region_filters.values())
+        return (has_exclude or 
+                self.hide_non_release or 
+                self.one_rom_per_game)
+    
+    def reset(self):
+        """Réinitialise tous les filtres (toutes les régions en include)"""
+        self.region_filters = {region: 'include' for region in self.REGIONS}
+        self.hide_non_release = False
+        self.one_rom_per_game = False
+        self.regex_mode = False
+    
+    @staticmethod
+    def get_game_regions(game_name: str) -> List[str]:
+        """Extrait les régions d'un nom de jeu"""
+        name = game_name.upper()
+        regions = []
+        
+        # Patterns de région communs
+        if 'USA' in name or 'US)' in name:
+            regions.append('USA')
+        if 'CANADA' in name or 'CA)' in name:
+            regions.append('Canada')
+        if 'EUROPE' in name or 'EU)' in name:
+            regions.append('Europe')
+        if 'FRANCE' in name or 'FR)' in name:
+            regions.append('France')
+        if 'GERMANY' in name or 'DE)' in name or 'GER)' in name:
+            regions.append('Germany')
+        if 'JAPAN' in name or 'JP)' in name or 'JPN)' in name:
+            regions.append('Japan')
+        if 'KOREA' in name or 'KR)' in name or 'KOR)' in name:
+            regions.append('Korea')
+        if 'WORLD' in name:
+            regions.append('World')
+        
+        # Autres régions
+        if re.search(r'\b(AUSTRALIA|ASIA|KOREA|BRAZIL|CHINA|RUSSIA|SCANDINAVIA|'
+                     r'SPAIN|FRANCE|GERMANY|ITALY|CANADA)\b', name):
+            if 'CANADA' in name:
+                regions.append('Canada')
+            else:
+                regions.append('Other')
+        
+        # Si aucune région trouvée
+        if not regions:
+            regions.append('Other')
+        
+        return regions
+    
+    @staticmethod
+    def is_non_release_game(game_name: str) -> bool:
+        """Vérifie si un jeu est une version non-release (demo, beta, proto)"""
+        name = game_name.upper()
+        non_release_patterns = [
+            r'\([^\)]*BETA[^\)]*\)',
+            r'\([^\)]*DEMO[^\)]*\)',
+            r'\([^\)]*PROTO[^\)]*\)',
+            r'\([^\)]*SAMPLE[^\)]*\)',
+            r'\([^\)]*KIOSK[^\)]*\)',
+            r'\([^\)]*PREVIEW[^\)]*\)',
+            r'\([^\)]*TEST[^\)]*\)',
+            r'\([^\)]*DEBUG[^\)]*\)',
+            r'\([^\)]*ALPHA[^\)]*\)',
+            r'\([^\)]*PRE-RELEASE[^\)]*\)',
+            r'\([^\)]*PRERELEASE[^\)]*\)',
+            r'\([^\)]*UNFINISHED[^\)]*\)',
+            r'\([^\)]*WIP[^\)]*\)',
+            r'\[[^\]]*BETA[^\]]*\]',
+            r'\[[^\]]*DEMO[^\]]*\]',
+            r'\[[^\]]*TEST[^\]]*\]'
+        ]
+        return any(re.search(pattern, name) for pattern in non_release_patterns)
+    
+    @staticmethod
+    def get_base_game_name(game_name: str) -> str:
+        """Obtient le nom de base du jeu (sans régions, versions, etc.)"""
+        base = game_name
+        
+        # Supprimer extensions
+        base = re.sub(r'\.(zip|7z|rar|gz|iso)$', '', base, flags=re.IGNORECASE)
+        
+        # Extraire info disque si présent
+        disc_info = ''
+        disc_match = (re.search(r'\(Dis[ck]\s*(\d+)\)', base, re.IGNORECASE) or
+                      re.search(r'\[Dis[ck]\s*(\d+)\]', base, re.IGNORECASE) or
+                      re.search(r'Dis[ck]\s*(\d+)', base, re.IGNORECASE) or
+                      re.search(r'\(CD\s*(\d+)\)', base, re.IGNORECASE) or
+                      re.search(r'CD\s*(\d+)', base, re.IGNORECASE))
+        if disc_match:
+            disc_info = f' (Disc {disc_match.group(1)})'
+        
+        # Supprimer contenu entre parenthèses et crochets
+        base = re.sub(r'\([^)]*\)', '', base)
+        base = re.sub(r'\[[^\]]*\]', '', base)
+        
+        # Normaliser espaces
+        base = re.sub(r'\s+', ' ', base).strip()
+        
+        # Rajouter info disque
+        base = base + disc_info
+        
+        return base
+    
+    def get_region_priority(self, game_name: str) -> int:
+        """Obtient la priorité de région pour un jeu (pour one-rom-per-game)"""
+        name = game_name.upper()
+        
+        for i, region in enumerate(self.region_priority):
+            region_upper = region.upper()
+            if region_upper in name:
+                return i
+        
+        return len(self.region_priority)  # Autres régions (priorité la plus basse)
+    
+    def apply_filters(self, games: List[Tuple]) -> List[Tuple]:
+        """
+        Applique les filtres à une liste de jeux
+        games: Liste de tuples (game_name, game_url, size)
+        Retourne: Liste filtrée de tuples
+        """
+        if not self.is_active():
+            return games
+        
+        filtered_games = []
+        
+        # Filtrage par région
+        for game in games:
+            game_name = game[0]
+            
+            # Vérifier les filtres de région
+            if self.region_filters:
+                game_regions = self.get_game_regions(game_name)
+                
+                # Vérifier si le jeu a au moins une région incluse
+                has_included_region = False
+                
+                for region in game_regions:
+                    filter_state = self.region_filters.get(region, 'include')
+                    if filter_state == 'include':
+                        has_included_region = True
+                        break  # Si on trouve une région incluse, c'est bon
+                
+                # Le jeu est affiché seulement s'il a au moins une région incluse
+                if not has_included_region:
+                    continue
+            
+            # Filtrer les non-release
+            if self.hide_non_release and self.is_non_release_game(game_name):
+                continue
+            
+            filtered_games.append(game)
+        
+        # Appliquer "one rom per game"
+        if self.one_rom_per_game:
+            filtered_games = self._apply_one_rom_per_game(filtered_games)
+        
+        return filtered_games
+    
+    def _apply_one_rom_per_game(self, games: List[Tuple]) -> List[Tuple]:
+        """Garde seulement une ROM par jeu selon la priorité de région"""
+        games_by_base = {}
+        
+        for game in games:
+            game_name = game[0]
+            base_name = self.get_base_game_name(game_name)
+            
+            if base_name not in games_by_base:
+                games_by_base[base_name] = []
+            
+            games_by_base[base_name].append(game)
+        
+        # Pour chaque jeu de base, garder celui avec la meilleure priorité
+        result = []
+        for base_name, game_list in games_by_base.items():
+            if len(game_list) == 1:
+                result.append(game_list[0])
+            else:
+                # Trier par priorité de région
+                sorted_games = sorted(game_list, 
+                                     key=lambda g: self.get_region_priority(g[0]))
+                result.append(sorted_games[0])
+        
+        return result

ports/RGSX/languages/de.json

@@ -67,7 +67,7 @@
     "menu_redownload_cache": "Spieleliste aktualisieren",
     "menu_music_enabled": "Musik aktiviert: {0}",
     "menu_music_disabled": "Musik deaktiviert",
-    "menu_restart": "Neustart",
+    "menu_restart": "RGSX neu starten",
     "menu_support": "Unterstützung",
     "menu_filter_platforms": "Systeme filtern",
     "filter_platforms_title": "Systemsichtbarkeit",
@@ -80,6 +80,7 @@
     "menu_allow_unknown_ext_enabled": "Ausblenden der Warnung bei unbekannter Erweiterung aktiviert",
     "menu_allow_unknown_ext_disabled": "Ausblenden der Warnung bei unbekannter Erweiterung deaktiviert",
     "menu_quit": "Beenden",
+    "menu_quit_app": "RGSX beenden",
     "support_dialog_title": "Support-Datei",
     "support_dialog_message": "Eine Support-Datei wurde mit allen Ihren Konfigurations- und Protokolldateien erstellt.\n\nDatei: {0}\n\nUm Hilfe zu erhalten:\n1. Treten Sie dem RGSX Discord-Server bei\n2. Beschreiben Sie Ihr Problem\n3. Teilen Sie diese ZIP-Datei\n\nDrücken Sie {1}, um zum Menü zurückzukehren.",
     "support_dialog_error": "Fehler beim Erstellen der Support-Datei:\n{0}\n\nDrücken Sie {1}, um zum Menü zurückzukehren.",
@@ -184,7 +185,9 @@
     "instruction_pause_settings": "Musik, Symlink-Option & API-Schlüsselstatus",
     "instruction_pause_restart": "RGSX neu starten um Konfiguration neu zu laden",
     "instruction_pause_support": "Eine Diagnose-ZIP-Datei für den Support erstellen",
-    "instruction_pause_quit": "RGSX Anwendung beenden",
+    "instruction_pause_quit": "Menü für Beenden oder Neustart aufrufen",
+    "instruction_quit_app": "RGSX Anwendung beenden",
+    "instruction_quit_restart": "RGSX Anwendung neu starten",
     "instruction_controls_help": "Komplette Referenz für Controller & Tastatur anzeigen",
     "instruction_controls_remap": "Tasten / Buttons neu zuordnen",
     "instruction_generic_back": "Zum vorherigen Menü zurückkehren",
@@ -242,7 +245,8 @@
     "history_game_options_title": "Spiel Optionen",
     "history_option_download_folder": "Datei lokalisieren",
     "history_option_extract_archive": "Archiv extrahieren",
-    "history_option_scraper": "Metadaten scrapen",
+    "history_option_open_file": "Datei öffnen",
+    "history_option_scraper": "Metadaten abrufen",
     "history_option_delete_game": "Spiel löschen",
     "history_option_error_info": "Fehlerdetails",
     "history_option_retry": "Download wiederholen",
@@ -339,7 +343,7 @@
     "web_restart_error": "Fehler beim Neustart: {0}",
     "web_support": "Support",
     "web_support_title": "📦 Support-Datei erstellt",
-    "web_support_message": "Support-Datei erfolgreich erstellt!\\n\\n📁 Inhalt:\\n• Steuerungskonfiguration\\n• Download-Verlauf\\n• RGSX-Einstellungen\\n• Anwendungsprotokolle\\n• Webserver-Protokolle\\n\\n💬 Um Hilfe zu erhalten:\\n1. Trete dem RGSX Discord bei\\n2. Beschreibe dein Problem\\n3. Teile diese ZIP-Datei\\n\\nDownload startet...",
+    "web_support_message": "Support-Datei erfolgreich erstellt!\n\n📁 Inhalt:\n• Steuerungskonfiguration\n• Download-Verlauf\n• RGSX-Einstellungen\n• Anwendungsprotokolle\n• Webserver-Protokolle\n\n💬 Um Hilfe zu erhalten:\n1. Trete dem RGSX Discord bei\n2. Beschreibe dein Problem\n3. Teile diese ZIP-Datei\n\nDownload startet...",
     "web_support_generating": "Support-Datei wird generiert...",
     "web_support_download": "Support-Datei herunterladen",
     "web_support_error": "Fehler beim Erstellen der Support-Datei: {0}",
@@ -367,10 +371,9 @@
     "web_filter_regex_mode": "Regex-Suche aktivieren",
     "web_filter_one_rom_per_game": "Eine ROM pro Spiel",
     "web_filter_configure_priority": "Regions-Prioritätsreihenfolge konfigurieren",
-    "filter_all": "Alles auswählen",
-    "filter_none": "Alles abwählen",
+    "filter_all": "Alle auswählen",
+    "filter_none": "Alle abwählen",
     "filter_apply": "Filter anwenden",
-    "filter_back": "Zurück",
     "accessibility_footer_font_size": "Fußzeilenschriftgröße: {0}",
     "popup_layout_changed_restart": "Layout geändert auf {0}x{1}. Bitte starten Sie die App neu.",
     "web_started": "Gestartet",
@@ -379,5 +382,33 @@
     "web_added_to_queue": "zur Warteschlange hinzugefügt",
     "web_download_success": "erfolgreich heruntergeladen!",
     "web_download_error_for": "Fehler beim Herunterladen von",
-    "web_already_present": "war bereits vorhanden"
+    "web_already_present": "war bereits vorhanden",
+    "filter_menu_title": "Filtermenü",
+    "filter_search_by_name": "Nach Namen suchen",
+    "filter_advanced": "Erweiterte Filterung",
+    "filter_advanced_title": "Erweiterte Spielfilterung",
+    "filter_region_title": "Nach Region filtern",
+    "filter_region_include": "Einschließen",
+    "filter_region_exclude": "Ausschließen",
+    "filter_region_usa": "USA",
+    "filter_region_canada": "Kanada",
+    "filter_region_europe": "Europa",
+    "filter_region_france": "Frankreich",
+    "filter_region_germany": "Deutschland",
+    "filter_region_japan": "Japan",
+    "filter_region_korea": "Korea",
+    "filter_region_world": "Welt",
+    "filter_region_other": "Andere",
+    "filter_other_options": "Weitere Optionen",
+    "filter_hide_non_release": "Demos/Betas/Protos ausblenden",
+    "filter_one_rom_per_game": "Eine ROM pro Spiel",
+    "filter_priority_order": "Prioritätsreihenfolge",
+    "filter_priority_title": "Regionsprioritätskonfiguration",
+    "filter_priority_desc": "Prioritätsreihenfolge für \"Eine ROM pro Spiel\" festlegen",
+    "filter_regex_mode": "Regex-Modus",
+    "filter_apply_filters": "Anwenden",
+    "filter_reset_filters": "Zurücksetzen",
+    "filter_back": "Zurück",
+    "filter_active": "Filter aktiv",
+    "filter_games_shown": "{0} Spiel(e) angezeigt"
 }

ports/RGSX/languages/en.json

@@ -67,7 +67,7 @@
     "menu_redownload_cache": "Update games list",
     "menu_music_enabled": "Music enabled: {0}",
     "menu_music_disabled": "Music disabled",
-    "menu_restart": "Restart",
+    "menu_restart": "Restart RGSX",
     "menu_filter_platforms": "Filter systems",
     "filter_platforms_title": "Systems visibility",
     "filter_platforms_info": "Visible: {0} | Hidden: {1} / Total: {2}",
@@ -80,6 +80,7 @@
     "menu_allow_unknown_ext_disabled": "Hide unknown extension warning disabled",
     "menu_support": "Support",
     "menu_quit": "Quit",
+    "menu_quit_app": "Quit RGSX",
     "button_yes": "Yes",
     "button_no": "No",
     "button_OK": "OK",
@@ -186,7 +187,9 @@
     "instruction_pause_settings": "Music, symlink option & API keys status",
     "instruction_pause_restart": "Restart RGSX to reload configuration",
     "instruction_pause_support": "Generate a diagnostic ZIP file for support",
-    "instruction_pause_quit": "Exit the RGSX application",
+    "instruction_pause_quit": "Access menu to quit or restart",
+    "instruction_quit_app": "Exit the RGSX application",
+    "instruction_quit_restart": "Restart the RGSX application",
     "instruction_controls_help": "Show full controller & keyboard reference",
     "instruction_controls_remap": "Change button / key bindings",
     "instruction_generic_back": "Return to the previous menu",
@@ -244,6 +247,7 @@
     "history_game_options_title": "Game Options",
     "history_option_download_folder": "Locate file",
     "history_option_extract_archive": "Extract archive",
+    "history_option_open_file": "Open file",
     "history_option_scraper": "Scrape metadata",
     "history_option_delete_game": "Delete game",
     "history_option_error_info": "Error details",
@@ -341,7 +345,7 @@
     "web_restart_error": "Restart error: {0}",
     "web_support": "Support",
     "web_support_title": "📦 Support File Generated",
-    "web_support_message": "Support file created successfully!\\n\\n📁 Contents:\\n• Controls configuration\\n• Download history\\n• RGSX settings\\n• Application logs\\n• Web server logs\\n\\n💬 To get help:\\n1. Join RGSX Discord\\n2. Describe your issue\\n3. Share this ZIP file\\n\\nDownload will start...",
+    "web_support_message": "Support file created successfully!\n\n📁 Contents:\n• Controls configuration\n• Download history\n• RGSX settings\n• Application logs\n• Web server logs\n\n💬 To get help:\n1. Join RGSX Discord\n2. Describe your issue\n3. Share this ZIP file\n\nDownload will start...",
     "web_support_generating": "Generating support file...",
     "web_support_download": "Download support file",
     "web_support_error": "Error generating support file: {0}",
@@ -367,10 +371,9 @@
     "web_filter_regex_mode": "Enable Regex Search",
     "web_filter_one_rom_per_game": "One ROM Per Game",
     "web_filter_configure_priority": "Configure region priority order",
-    "filter_all": "Check All",
-    "filter_none": "Uncheck All",
-    "filter_apply": "Apply Filter",
-    "filter_back": "Back",
+    "filter_all": "Check all",
+    "filter_none": "Uncheck all",
+    "filter_apply": "Apply filter",
     "accessibility_footer_font_size": "Footer font size: {0}",
     "popup_layout_changed_restart": "Layout changed to {0}x{1}. Please restart the app to apply.",
     "web_started": "Started",
@@ -379,5 +382,33 @@
     "web_added_to_queue": "added to queue",
     "web_download_success": "downloaded successfully!",
     "web_download_error_for": "Error downloading",
-    "web_already_present": "was already present"
+    "web_already_present": "was already present",
+    "filter_menu_title": "Filter Menu",
+    "filter_search_by_name": "Search by name",
+    "filter_advanced": "Advanced filtering",
+    "filter_advanced_title": "Advanced Game Filtering",
+    "filter_region_title": "Filter by region",
+    "filter_region_include": "Include",
+    "filter_region_exclude": "Exclude",
+    "filter_region_usa": "USA",
+    "filter_region_canada": "Canada",
+    "filter_region_europe": "Europe",
+    "filter_region_france": "France",
+    "filter_region_germany": "Germany",
+    "filter_region_japan": "Japan",
+    "filter_region_korea": "Korea",
+    "filter_region_world": "World",
+    "filter_region_other": "Other",
+    "filter_other_options": "Other options",
+    "filter_hide_non_release": "Hide Demos/Betas/Protos",
+    "filter_one_rom_per_game": "One ROM per game",
+    "filter_priority_order": "Priority order",
+    "filter_priority_title": "Region Priority Configuration",
+    "filter_priority_desc": "Set preference order for \"One ROM per game\"",
+    "filter_regex_mode": "Regex Mode",
+    "filter_apply_filters": "Apply",
+    "filter_reset_filters": "Reset",
+    "filter_back": "Back",
+    "filter_active": "Filter active",
+    "filter_games_shown": "{0} game(s) shown"
 }

ports/RGSX/languages/es.json

@@ -67,7 +67,7 @@
     "menu_redownload_cache": "Actualizar lista de juegos",
     "menu_music_enabled": "Música activada: {0}",
     "menu_music_disabled": "Música desactivada",
-    "menu_restart": "Reiniciar",
+    "menu_restart": "Reiniciar RGSX",
     "menu_support": "Soporte",
     "menu_filter_platforms": "Filtrar sistemas",
     "filter_platforms_title": "Visibilidad de sistemas",
@@ -80,6 +80,7 @@
     "menu_allow_unknown_ext_enabled": "Aviso de extensión desconocida oculto (activado)",
     "menu_allow_unknown_ext_disabled": "Aviso de extensión desconocida visible (desactivado)",
     "menu_quit": "Salir",
+    "menu_quit_app": "Salir de RGSX",
     "support_dialog_title": "Archivo de soporte",
     "support_dialog_message": "Se ha creado un archivo de soporte con todos sus archivos de configuración y registros.\n\nArchivo: {0}\n\nPara obtener ayuda:\n1. Únete al servidor Discord de RGSX\n2. Describe tu problema\n3. Comparte este archivo ZIP\n\nPresiona {1} para volver al menú.",
     "support_dialog_error": "Error al generar el archivo de soporte:\n{0}\n\nPresiona {1} para volver al menú.",
@@ -186,7 +187,9 @@
     "instruction_pause_settings": "Música, opción symlink y estado de claves API",
     "instruction_pause_restart": "Reiniciar RGSX para recargar configuración",
     "instruction_pause_support": "Generar un archivo ZIP de diagnóstico para soporte",
-    "instruction_pause_quit": "Salir de la aplicación RGSX",
+    "instruction_pause_quit": "Acceder al menú para salir o reiniciar",
+    "instruction_quit_app": "Salir de la aplicación RGSX",
+    "instruction_quit_restart": "Reiniciar la aplicación RGSX",
     "instruction_controls_help": "Mostrar referencia completa de mando y teclado",
     "instruction_controls_remap": "Cambiar asignación de botones / teclas",
     "instruction_generic_back": "Volver al menú anterior",
@@ -244,7 +247,8 @@
     "history_game_options_title": "Opciones del juego",
     "history_option_download_folder": "Localizar archivo",
     "history_option_extract_archive": "Extraer archivo",
-    "history_option_scraper": "Scraper metadatos",
+    "history_option_open_file": "Abrir archivo",
+    "history_option_scraper": "Obtener metadatos",
     "history_option_delete_game": "Eliminar juego",
     "history_option_error_info": "Detalles del error",
     "history_option_retry": "Reintentar descarga",
@@ -341,7 +345,7 @@
     "web_restart_error": "Error al reiniciar: {0}",
     "web_support": "Soporte",
     "web_support_title": "📦 Archivo de soporte generado",
-    "web_support_message": "¡Archivo de soporte creado con éxito!\\n\\n📁 Contenido:\\n• Configuración de controles\\n• Historial de descargas\\n• Configuración RGSX\\n• Registros de la aplicación\\n• Registros del servidor web\\n\\n💬 Para obtener ayuda:\\n1. Únete al Discord de RGSX\\n2. Describe tu problema\\n3. Comparte este archivo ZIP\\n\\nLa descarga comenzará...",
+    "web_support_message": "¡Archivo de soporte creado con éxito!\n\n📁 Contenido:\n• Configuración de controles\n• Historial de descargas\n• Configuración RGSX\n• Registros de la aplicación\n• Registros del servidor web\n\n💬 Para obtener ayuda:\n1. Únete al Discord de RGSX\n2. Describe tu problema\n3. Comparte este archivo ZIP\n\nLa descarga comenzará...",
     "web_support_generating": "Generando archivo de soporte...",
     "web_support_download": "Descargar archivo de soporte",
     "web_support_error": "Error al generar el archivo de soporte: {0}",
@@ -370,7 +374,6 @@
     "filter_all": "Marcar todo",
     "filter_none": "Desmarcar todo",
     "filter_apply": "Aplicar filtro",
-    "filter_back": "Volver",
     "accessibility_footer_font_size": "Tamaño fuente pie de página: {0}",
     "popup_layout_changed_restart": "Diseño cambiado a {0}x{1}. Reinicie la app para aplicar.",
     "web_started": "Iniciado",
@@ -379,5 +382,33 @@
     "web_added_to_queue": "añadido a la cola",
     "web_download_success": "¡descargado con éxito!",
     "web_download_error_for": "Error al descargar",
-    "web_already_present": "ya estaba presente"
+    "web_already_present": "ya estaba presente",
+    "filter_menu_title": "Menú de filtros",
+    "filter_search_by_name": "Buscar por nombre",
+    "filter_advanced": "Filtrado avanzado",
+    "filter_advanced_title": "Filtrado avanzado de juegos",
+    "filter_region_title": "Filtrar por región",
+    "filter_region_include": "Incluir",
+    "filter_region_exclude": "Excluir",
+    "filter_region_usa": "EE.UU.",
+    "filter_region_canada": "Canadá",
+    "filter_region_europe": "Europa",
+    "filter_region_france": "Francia",
+    "filter_region_germany": "Alemania",
+    "filter_region_japan": "Japón",
+    "filter_region_korea": "Corea",
+    "filter_region_world": "Mundial",
+    "filter_region_other": "Otros",
+    "filter_other_options": "Otras opciones",
+    "filter_hide_non_release": "Ocultar Demos/Betas/Protos",
+    "filter_one_rom_per_game": "Una ROM por juego",
+    "filter_priority_order": "Orden de prioridad",
+    "filter_priority_title": "Configuración de prioridad de regiones",
+    "filter_priority_desc": "Definir orden de preferencia para \"Una ROM por juego\"",
+    "filter_regex_mode": "Modo Regex",
+    "filter_apply_filters": "Aplicar",
+    "filter_reset_filters": "Restablecer",
+    "filter_back": "Volver",
+    "filter_active": "Filtro activo",
+    "filter_games_shown": "{0} juego(s) mostrado(s)"
 }

ports/RGSX/languages/fr.json

@@ -67,9 +67,10 @@
     "menu_redownload_cache": "Mettre à jour la liste des jeux",
     "menu_support": "Support",
     "menu_quit": "Quitter",
+    "menu_quit_app": "Quitter RGSX",
     "menu_music_enabled": "Musique activée : {0}",
     "menu_music_disabled": "Musique désactivée",
-    "menu_restart": "Redémarrer",
+    "menu_restart": "Redémarrer RGSX",
     "menu_filter_platforms": "Filtrer les systèmes",
     "filter_platforms_title": "Affichage des systèmes",
     "filter_platforms_info": "Visibles: {0} | Masqués: {1} / Total: {2}",
@@ -186,7 +187,9 @@
     "instruction_pause_settings": "Musique, option symlink & statut des clés API",
     "instruction_pause_restart": "Redémarrer RGSX pour recharger la configuration",
     "instruction_pause_support": "Générer un fichier ZIP de diagnostic pour l'assistance",
-    "instruction_pause_quit": "Quitter l'application RGSX",
+    "instruction_pause_quit": "Accéder au menu pour quitter ou redémarrer",
+    "instruction_quit_app": "Quitter l'application RGSX",
+    "instruction_quit_restart": "Redémarrer l'application RGSX",
     "instruction_controls_help": "Afficher la référence complète manette & clavier",
     "instruction_controls_remap": "Modifier l'association boutons / touches",
     "instruction_generic_back": "Revenir au menu précédent",
@@ -244,10 +247,11 @@
     "history_game_options_title": "Options du jeu",
     "history_option_download_folder": "Localiser le fichier",
     "history_option_extract_archive": "Extraire l'archive",
-    "history_option_scraper": "Scraper métadonnées",
+    "history_option_open_file": "Ouvrir le fichier",
+    "history_option_scraper": "Récupérer métadonnées",
     "history_option_delete_game": "Supprimer le jeu",
     "history_option_error_info": "Détails de l'erreur",
-    "history_option_retry": "Réessayer le téléchargement",
+    "history_option_retry": "Retenter le téléchargement",
     "history_option_back": "Retour",
     "history_folder_path_label": "Chemin de destination :",
     "history_scraper_not_implemented": "Scraper pas encore implémenté",
@@ -341,7 +345,7 @@
     "web_restart_error": "Erreur lors du redémarrage : {0}",
     "web_support": "Support",
     "web_support_title": "📦 Fichier de support généré",
-    "web_support_message": "Le fichier de support a été créé avec succès !\\n\\n📁 Contenu :\\n• Configuration des contrôles\\n• Historique des téléchargements\\n• Paramètres RGSX\\n• Logs de l'application\\n• Logs du serveur web\\n\\n💬 Pour obtenir de l'aide :\\n1. Rejoignez le Discord RGSX\\n2. Décrivez votre problème\\n3. Partagez ce fichier ZIP\\n\\nLe téléchargement va démarrer...",
+    "web_support_message": "Le fichier de support a été créé avec succès !\n\n📁 Contenu :\n• Configuration des contrôles\n• Historique des téléchargements\n• Paramètres RGSX\n• Logs de l'application\n• Logs du serveur web\n\n💬 Pour obtenir de l'aide :\n1. Rejoignez le Discord RGSX\n2. Décrivez votre problème\n3. Partagez ce fichier ZIP\n\nLe téléchargement va démarrer...",
     "web_support_generating": "Génération du fichier de support...",
     "web_support_download": "Télécharger le fichier de support",
     "web_support_error": "Erreur lors de la génération du fichier de support : {0}",
@@ -370,7 +374,6 @@
     "filter_all": "Tout cocher",
     "filter_none": "Tout décocher",
     "filter_apply": "Appliquer filtre",
-    "filter_back": "Retour",
     "accessibility_footer_font_size": "Taille police pied de page : {0}",
     "popup_layout_changed_restart": "Disposition changée en {0}x{1}. Veuillez redémarrer l'app pour appliquer.",
     "web_started": "Démarré",
@@ -379,5 +382,33 @@
     "web_added_to_queue": "ajouté à la queue",
     "web_download_success": "téléchargé avec succès!",
     "web_download_error_for": "Erreur lors du téléchargement de",
-    "web_already_present": "était déjà présent"
+    "web_already_present": "était déjà présent",
+    "filter_menu_title": "Menu Filtrage",
+    "filter_search_by_name": "Recherche par nom",
+    "filter_advanced": "Filtrage avancé",
+    "filter_advanced_title": "Filtrage avancé des jeux",
+    "filter_region_title": "Filtrer par région",
+    "filter_region_include": "Inclure",
+    "filter_region_exclude": "Exclure",
+    "filter_region_usa": "USA",
+    "filter_region_canada": "Canada",
+    "filter_region_europe": "Europe",
+    "filter_region_france": "France",
+    "filter_region_germany": "Allemagne",
+    "filter_region_japan": "Japon",
+    "filter_region_korea": "Corée",
+    "filter_region_world": "Monde",
+    "filter_region_other": "Autres",
+    "filter_other_options": "Autres options",
+    "filter_hide_non_release": "Masquer Démos/Betas/Protos",
+    "filter_one_rom_per_game": "Une ROM par jeu",
+    "filter_priority_order": "Ordre de priorité",
+    "filter_priority_title": "Configuration de la priorité des régions",
+    "filter_priority_desc": "Définir l'ordre de préférence pour \"Une ROM par jeu\"",
+    "filter_regex_mode": "Mode Regex",
+    "filter_apply_filters": "Appliquer",
+    "filter_reset_filters": "Réinitialiser",
+    "filter_back": "Retour",
+    "filter_active": "Filtre actif",
+    "filter_games_shown": "{0} jeu(x) affiché(s)"
 }

ports/RGSX/languages/it.json

@@ -67,7 +67,7 @@
     "menu_redownload_cache": "Aggiorna elenco giochi",
     "menu_music_enabled": "Musica attivata: {0}",
     "menu_music_disabled": "Musica disattivata",
-    "menu_restart": "Riavvia",
+    "menu_restart": "Riavvia RGSX",
     "menu_support": "Supporto",
     "menu_filter_platforms": "Filtra sistemi",
     "filter_platforms_title": "Visibilità sistemi",
@@ -80,6 +80,7 @@
     "menu_allow_unknown_ext_enabled": "Nascondi avviso estensione sconosciuta abilitato",
     "menu_allow_unknown_ext_disabled": "Nascondi avviso estensione sconosciuta disabilitato",
     "menu_quit": "Esci",
+    "menu_quit_app": "Esci da RGSX",
     "support_dialog_title": "File di supporto",
     "support_dialog_message": "È stato creato un file di supporto con tutti i file di configurazione e di registro.\n\nFile: {0}\n\nPer ottenere aiuto:\n1. Unisciti al server Discord RGSX\n2. Descrivi il tuo problema\n3. Condividi questo file ZIP\n\nPremi {1} per tornare al menu.",
     "support_dialog_error": "Errore durante la generazione del file di supporto:\n{0}\n\nPremi {1} per tornare al menu.",
@@ -183,7 +184,9 @@
     "instruction_pause_settings": "Musica, opzione symlink e stato chiavi API",
     "instruction_pause_restart": "Riavvia RGSX per ricaricare la configurazione",
     "instruction_pause_support": "Genera un file ZIP diagnostico per il supporto",
-    "instruction_pause_quit": "Uscire dall'applicazione RGSX",
+    "instruction_pause_quit": "Accedere al menu per uscire o riavviare",
+    "instruction_quit_app": "Uscire dall'applicazione RGSX",
+    "instruction_quit_restart": "Riavviare l'applicazione RGSX",
     "instruction_controls_help": "Mostrare riferimento completo controller & tastiera",
     "instruction_controls_remap": "Modificare associazione pulsanti / tasti",
     "instruction_generic_back": "Tornare al menu precedente",
@@ -241,6 +244,7 @@
     "history_game_options_title": "Opzioni gioco",
     "history_option_download_folder": "Localizza file",
     "history_option_extract_archive": "Estrai archivio",
+    "history_option_open_file": "Apri file",
     "history_option_scraper": "Scraper metadati",
     "history_option_delete_game": "Elimina gioco",
     "history_option_error_info": "Dettagli errore",
@@ -338,7 +342,7 @@
     "web_restart_error": "Errore durante il riavvio: {0}",
     "web_support": "Supporto",
     "web_support_title": "📦 File di supporto generato",
-    "web_support_message": "File di supporto creato con successo!\\n\\n📁 Contenuto:\\n• Configurazione controlli\\n• Cronologia download\\n• Impostazioni RGSX\\n• Log dell'applicazione\\n• Log del server web\\n\\n💬 Per ottenere aiuto:\\n1. Unisciti al Discord RGSX\\n2. Descrivi il tuo problema\\n3. Condividi questo file ZIP\\n\\nIl download inizierà...",
+    "web_support_message": "File di supporto creato con successo!\n\n📁 Contenuto:\n• Configurazione controlli\n• Cronologia download\n• Impostazioni RGSX\n• Log dell'applicazione\n• Log del server web\n\n💬 Per ottenere aiuto:\n1. Unisciti al Discord RGSX\n2. Descrivi il tuo problema\n3. Condividi questo file ZIP\n\nIl download inizierà...",
     "web_support_generating": "Generazione file di supporto...",
     "web_support_download": "Scarica file di supporto",
     "web_support_error": "Errore nella generazione del file di supporto: {0}",
@@ -370,7 +374,6 @@
     "filter_all": "Seleziona tutto",
     "filter_none": "Deseleziona tutto",
     "filter_apply": "Applica filtro",
-    "filter_back": "Indietro",
     "accessibility_footer_font_size": "Dimensione carattere piè di pagina: {0}",
     "popup_layout_changed_restart": "Layout cambiato a {0}x{1}. Riavvia l'app per applicare.",
     "web_started": "Avviato",
@@ -379,5 +382,33 @@
     "web_added_to_queue": "aggiunto alla coda",
     "web_download_success": "scaricato con successo!",
     "web_download_error_for": "Errore durante il download di",
-    "web_already_present": "era già presente"
+    "web_already_present": "era già presente",
+    "filter_menu_title": "Menu filtri",
+    "filter_search_by_name": "Cerca per nome",
+    "filter_advanced": "Filtro avanzato",
+    "filter_advanced_title": "Filtro avanzato giochi",
+    "filter_region_title": "Filtra per regione",
+    "filter_region_include": "Includi",
+    "filter_region_exclude": "Escludi",
+    "filter_region_usa": "USA",
+    "filter_region_canada": "Canada",
+    "filter_region_europe": "Europa",
+    "filter_region_france": "Francia",
+    "filter_region_germany": "Germania",
+    "filter_region_japan": "Giappone",
+    "filter_region_korea": "Corea",
+    "filter_region_world": "Mondo",
+    "filter_region_other": "Altro",
+    "filter_other_options": "Altre opzioni",
+    "filter_hide_non_release": "Nascondi Demo/Beta/Proto",
+    "filter_one_rom_per_game": "Una ROM per gioco",
+    "filter_priority_order": "Ordine di priorità",
+    "filter_priority_title": "Configurazione priorità regioni",
+    "filter_priority_desc": "Imposta ordine di preferenza per \"Una ROM per gioco\"",
+    "filter_regex_mode": "Modalità Regex",
+    "filter_apply_filters": "Applica",
+    "filter_reset_filters": "Reimposta",
+    "filter_back": "Indietro",
+    "filter_active": "Filtro attivo",
+    "filter_games_shown": "{0} gioco/i mostrato/i"
 }

ports/RGSX/languages/pt.json

@@ -67,7 +67,7 @@
     "menu_redownload_cache": "Atualizar lista de jogos",
     "menu_music_enabled": "Música ativada: {0}",
     "menu_music_disabled": "Música desativada",
-    "menu_restart": "Reiniciar",
+    "menu_restart": "Reiniciar RGSX",
     "menu_support": "Suporte",
     "menu_filter_platforms": "Filtrar sistemas",
     "filter_platforms_title": "Visibilidade dos sistemas",
@@ -80,6 +80,7 @@
     "menu_allow_unknown_ext_enabled": "Aviso de extensão desconhecida oculto (ativado)",
     "menu_allow_unknown_ext_disabled": "Aviso de extensão desconhecida visível (desativado)",
     "menu_quit": "Sair",
+    "menu_quit_app": "Sair do RGSX",
     "support_dialog_title": "Arquivo de suporte",
     "support_dialog_message": "Foi criado um arquivo de suporte com todos os seus arquivos de configuração e logs.\n\nArquivo: {0}\n\nPara obter ajuda:\n1. Junte-se ao servidor Discord RGSX\n2. Descreva seu problema\n3. Compartilhe este arquivo ZIP\n\nPressione {1} para voltar ao menu.",
     "support_dialog_error": "Erro ao gerar o arquivo de suporte:\n{0}\n\nPressione {1} para voltar ao menu.",
@@ -185,7 +186,9 @@
     "instruction_pause_settings": "Música, opção symlink e status das chaves API",
     "instruction_pause_restart": "Reiniciar RGSX para recarregar configuração",
     "instruction_pause_support": "Gerar um arquivo ZIP de diagnóstico para suporte",
-    "instruction_pause_quit": "Sair da aplicação RGSX",
+    "instruction_pause_quit": "Acessar menu para sair ou reiniciar",
+    "instruction_quit_app": "Sair da aplicação RGSX",
+    "instruction_quit_restart": "Reiniciar a aplicação RGSX",
     "instruction_controls_help": "Mostrar referência completa de controle e teclado",
     "instruction_controls_remap": "Modificar associação de botões / teclas",
     "instruction_generic_back": "Voltar ao menu anterior",
@@ -243,7 +246,8 @@
     "history_game_options_title": "Opções do jogo",
     "history_option_download_folder": "Localizar arquivo",
     "history_option_extract_archive": "Extrair arquivo",
-    "history_option_scraper": "Scraper metadados",
+    "history_option_open_file": "Abrir arquivo",
+    "history_option_scraper": "Obter metadados",
     "history_option_delete_game": "Excluir jogo",
     "history_option_error_info": "Detalhes do erro",
     "history_option_retry": "Tentar novamente",
@@ -340,7 +344,7 @@
     "web_restart_error": "Erro ao reiniciar: {0}",
     "web_support": "Suporte",
     "web_support_title": "📦 Arquivo de suporte gerado",
-    "web_support_message": "Arquivo de suporte criado com sucesso!\\n\\n📁 Conteúdo:\\n• Configuração de controles\\n• Histórico de downloads\\n• Configurações RGSX\\n• Logs da aplicação\\n• Logs do servidor web\\n\\n💬 Para obter ajuda:\\n1. Entre no Discord RGSX\\n2. Descreva seu problema\\n3. Compartilhe este arquivo ZIP\\n\\nO download vai começar...",
+    "web_support_message": "Arquivo de suporte criado com sucesso!\n\n📁 Conteúdo:\n• Configuração de controles\n• Histórico de downloads\n• Configurações RGSX\n• Logs da aplicação\n• Logs do servidor web\n\n💬 Para obter ajuda:\n1. Entre no Discord RGSX\n2. Descreva seu problema\n3. Compartilhe este arquivo ZIP\n\nO download vai começar...",
     "web_support_generating": "Gerando arquivo de suporte...",
     "web_support_download": "Baixar arquivo de suporte",
     "web_support_error": "Erro ao gerar arquivo de suporte: {0}",
@@ -370,7 +374,6 @@
     "filter_all": "Marcar tudo",
     "filter_none": "Desmarcar tudo",
     "filter_apply": "Aplicar filtro",
-    "filter_back": "Voltar",
     "accessibility_footer_font_size": "Tamanho da fonte do rodapé: {0}",
     "popup_layout_changed_restart": "Layout alterado para {0}x{1}. Reinicie o app para aplicar.",
     "web_started": "Iniciado",
@@ -379,5 +382,33 @@
     "web_added_to_queue": "adicionado à fila",
     "web_download_success": "baixado com sucesso!",
     "web_download_error_for": "Erro ao baixar",
-    "web_already_present": "já estava presente"
+    "web_already_present": "já estava presente",
+    "filter_menu_title": "Menu de filtros",
+    "filter_search_by_name": "Pesquisar por nome",
+    "filter_advanced": "Filtragem avançada",
+    "filter_advanced_title": "Filtragem avançada de jogos",
+    "filter_region_title": "Filtrar por região",
+    "filter_region_include": "Incluir",
+    "filter_region_exclude": "Excluir",
+    "filter_region_usa": "EUA",
+    "filter_region_canada": "Canadá",
+    "filter_region_europe": "Europa",
+    "filter_region_france": "França",
+    "filter_region_germany": "Alemanha",
+    "filter_region_japan": "Japão",
+    "filter_region_korea": "Coreia",
+    "filter_region_world": "Mundial",
+    "filter_region_other": "Outros",
+    "filter_other_options": "Outras opções",
+    "filter_hide_non_release": "Ocultar Demos/Betas/Protos",
+    "filter_one_rom_per_game": "Uma ROM por jogo",
+    "filter_priority_order": "Ordem de prioridade",
+    "filter_priority_title": "Configuração de prioridade de regiões",
+    "filter_priority_desc": "Definir ordem de preferência para \"Uma ROM por jogo\"",
+    "filter_regex_mode": "Modo Regex",
+    "filter_apply_filters": "Aplicar",
+    "filter_reset_filters": "Redefinir",
+    "filter_back": "Voltar",
+    "filter_active": "Filtro ativo",
+    "filter_games_shown": "{0} jogo(s) exibido(s)"
 }

ports/RGSX/network.py

@@ -453,8 +453,102 @@ async def check_for_updates():
         config.loading_progress = 5.0
         config.needs_redraw = True
 
-        response = requests.get(OTA_VERSION_ENDPOINT, timeout=5)
-        response.raise_for_status()
+        # Liste des endpoints à essayer (GitHub principal, puis fallback)
+        endpoints = [
+            OTA_VERSION_ENDPOINT,
+            "https://retrogamesets.fr/softs/version.json"
+        ]
+        
+        response = None
+        last_error = None
+        
+        for endpoint_index, endpoint in enumerate(endpoints):
+            is_fallback = endpoint_index > 0
+            if is_fallback:
+                logger.info(f"Tentative sur endpoint de secours : {endpoint}")
+            
+            # Gestion des erreurs de rate limit GitHub (429) avec retry
+            max_retries = 3 if not is_fallback else 1  # Moins de retries sur fallback
+            retry_count = 0
+            
+            while retry_count < max_retries:
+                try:
+                    response = requests.get(endpoint, timeout=10)
+                    
+                    # Gestion spécifique des erreurs 429 (Too Many Requests) - surtout pour GitHub
+                    if response.status_code == 429:
+                        retry_after = response.headers.get('retry-after')
+                        x_ratelimit_remaining = response.headers.get('x-ratelimit-remaining', '1')
+                        x_ratelimit_reset = response.headers.get('x-ratelimit-reset')
+                        
+                        if retry_after:
+                            # En-tête retry-after présent : attendre le nombre de secondes spécifié
+                            wait_time = int(retry_after)
+                            logger.warning(f"Rate limit atteint (429) sur {endpoint}. Attente de {wait_time}s (retry-after header)")
+                        elif x_ratelimit_remaining == '0' and x_ratelimit_reset:
+                            # x-ratelimit-remaining est 0 : attendre jusqu'à x-ratelimit-reset
+                            import time
+                            reset_time = int(x_ratelimit_reset)
+                            current_time = int(time.time())
+                            wait_time = max(reset_time - current_time, 60)  # Minimum 60s
+                            logger.warning(f"Rate limit atteint (429) sur {endpoint}. Attente de {wait_time}s (x-ratelimit-reset)")
+                        else:
+                            # Pas d'en-têtes spécifiques : attendre au moins 60s
+                            wait_time = 60
+                            logger.warning(f"Rate limit atteint (429) sur {endpoint}. Attente de {wait_time}s par défaut")
+                        
+                        if retry_count < max_retries - 1:
+                            logger.info(f"Nouvelle tentative dans {wait_time}s... ({retry_count + 1}/{max_retries})")
+                            await asyncio.sleep(wait_time)
+                            retry_count += 1
+                            continue
+                        else:
+                            # Si rate limit persistant et qu'on est sur GitHub, essayer le fallback
+                            if not is_fallback:
+                                logger.warning(f"Rate limit GitHub persistant, passage au serveur de secours")
+                                break  # Sortir de la boucle retry pour essayer le prochain endpoint
+                            raise requests.exceptions.HTTPError(
+                                f"Limite de débit atteinte (429). Veuillez réessayer plus tard."
+                            )
+                    
+                    response.raise_for_status()
+                    # Succès, sortir de toutes les boucles
+                    logger.debug(f"Version récupérée avec succès depuis : {endpoint}")
+                    break
+                    
+                except requests.exceptions.HTTPError as e:
+                    last_error = e
+                    if response and response.status_code == 429:
+                        # 429 géré au-dessus, continuer la boucle ou passer au fallback
+                        retry_count += 1
+                        if retry_count >= max_retries:
+                            break  # Passer au prochain endpoint
+                    else:
+                        # Erreur HTTP autre que 429
+                        logger.warning(f"Erreur HTTP {response.status_code if response else 'inconnue'} sur {endpoint}")
+                        break  # Passer au prochain endpoint
+                        
+                except requests.exceptions.RequestException as e:
+                    last_error = e
+                    if retry_count < max_retries - 1:
+                        # Erreur réseau, réessayer avec backoff exponentiel
+                        wait_time = 2 ** retry_count  # 1s, 2s, 4s
+                        logger.warning(f"Erreur réseau sur {endpoint}. Nouvelle tentative dans {wait_time}s...")
+                        await asyncio.sleep(wait_time)
+                        retry_count += 1
+                    else:
+                        logger.warning(f"Erreur réseau persistante sur {endpoint} : {e}")
+                        break  # Passer au prochain endpoint
+            
+            # Si on a une réponse valide, sortir de la boucle des endpoints
+            if response and response.status_code == 200:
+                break
+        
+        # Si aucun endpoint n'a fonctionné
+        if not response or response.status_code != 200:
+            raise last_error if last_error else requests.exceptions.RequestException(
+                "Impossible de vérifier les mises à jour sur tous les serveurs"
+            )
         
         # Accepter différents content-types (application/json, text/plain, text/html)
         content_type = response.headers.get("content-type", "")

ports/RGSX/rgsx_settings.py

@@ -339,3 +339,26 @@ def get_language(settings=None):
     if settings is None:
         settings = load_rgsx_settings()
     return settings.get("language", "en")
+
+
+def load_game_filters():
+    """Charge les filtres de jeux depuis rgsx_settings.json."""
+    try:
+        settings = load_rgsx_settings()
+        return settings.get("game_filters", {})
+    except Exception as e:
+        logger.error(f"Error loading game filters: {str(e)}")
+        return {}
+
+
+def save_game_filters(filters_dict):
+    """Sauvegarde les filtres de jeux dans rgsx_settings.json."""
+    try:
+        settings = load_rgsx_settings()
+        settings["game_filters"] = filters_dict
+        save_rgsx_settings(settings)
+        logger.debug(f"Game filters saved: {filters_dict}")
+        return True
+    except Exception as e:
+        logger.error(f"Error saving game filters: {str(e)}")
+        return False

ports/RGSX/rgsx_web.py

@@ -246,11 +246,11 @@ def get_translation(key, default=None):
     return key
 
 # Fonction pour normaliser les tailles de fichier
-def normalize_size(size_str):
+def normalize_size(size_str, lang='en'):
     """
     Normalise une taille de fichier dans différents formats (Ko, KiB, Mo, MiB, Go, GiB)
-    en un format uniforme (Mo ou Go).
-    Exemples: "150 Mo" -> "150 Mo", "1.5 Go" -> "1.5 Go", "500 Ko" -> "0.5 Mo", "2 GiB" -> "2.15 Go"
+    en un format uniforme selon la langue (MB/GB pour anglais, Mo/Go pour français).
+    Exemples: "150 Mo" -> "150 MB" (en), "1.5 Go" -> "1.5 GB" (en), "500 Ko" -> "0.5 MB"
     """
     if not size_str:
         return None
@@ -282,16 +282,24 @@ def normalize_size(size_str):
         elif unit in ['gio', 'gib']:
             value = value * 1024  # GiB en Mo
         
-        # Afficher en Go si > 1024 Mo, sinon en Mo
-        if value >= 1024:
-            return f"{value / 1024:.2f} Go".rstrip('0').rstrip('.')
+        # Déterminer les unités selon la langue
+        if lang == 'fr':
+            mb_unit = 'Mo'
+            gb_unit = 'Go'
         else:
-            # Arrondir à 1 décimale pour Mo
+            mb_unit = 'MB'
+            gb_unit = 'GB'
+        
+        # Afficher en GB/Go si > 1024 Mo, sinon en MB/Mo
+        if value >= 1024:
+            return f"{value / 1024:.2f} {gb_unit}".replace('.00 ', ' ').rstrip('0').rstrip('.')
+        else:
+            # Arrondir à 1 décimale pour MB/Mo
             rounded = round(value, 1)
             if rounded == int(rounded):
-                return f"{int(rounded)} Mo"
+                return f"{int(rounded)} {mb_unit}"
             else:
-                return f"{rounded} Mo".rstrip('0').rstrip('.')
+                return f"{rounded} {mb_unit}".rstrip('0').rstrip('.')
     except (ValueError, TypeError):
         return size_str  # Retourner original si conversion échoue
 
@@ -472,6 +480,20 @@ class RGSXHandler(BaseHTTPRequestHandler):
         """Répond avec un 404 générique."""
         self._set_headers('text/plain; charset=utf-8', status=404)
         self.wfile.write(b'Not found')
+    
+    def _get_language_from_cookies(self):
+        """Récupère la langue depuis les cookies ou retourne 'en' par défaut"""
+        cookie_header = self.headers.get('Cookie', '')
+        if cookie_header:
+            # Parser les cookies
+            cookies = {}
+            for cookie in cookie_header.split(';'):
+                cookie = cookie.strip()
+                if '=' in cookie:
+                    key, value = cookie.split('=', 1)
+                    cookies[key] = value
+            return cookies.get('language', 'en')
+        return 'en'
 
     def _asset_version(self, relative_path: str) -> str:
         """Retourne un identifiant de version basé sur la date de modification du fichier statique."""
@@ -681,7 +703,7 @@ class RGSXHandler(BaseHTTPRequestHandler):
                                         'game_name': game_name,
                                         'platform': platform_name,
                                         'url': game[1] if len(game) > 1 and isinstance(game, (list, tuple)) else None,
-                                        'size': normalize_size(game[2] if len(game) > 2 and isinstance(game, (list, tuple)) else None)
+                                        'size': normalize_size(game[2] if len(game) > 2 and isinstance(game, (list, tuple)) else None, self._get_language_from_cookies())
                                     })
                         except Exception as e:
                             logger.debug(f"Erreur lors de la recherche dans {platform_name}: {e}")
@@ -722,12 +744,15 @@ class RGSXHandler(BaseHTTPRequestHandler):
                 platform_name = path.split('/api/games/')[-1]
                 platform_name = urllib.parse.unquote(platform_name)
                 
+                # Récupérer la langue depuis les cookies ou utiliser 'en' par défaut
+                lang = self._get_language_from_cookies()
+                
                 games, _, games_last_modified = get_cached_games(platform_name)
                 games_formatted = [
                     {
                         'name': g[0],
                         'url': g[1] if len(g) > 1 else None,
-                        'size': normalize_size(g[2] if len(g) > 2 else None)
+                        'size': normalize_size(g[2] if len(g) > 2 else None, lang)
                     }
                     for g in games
                 ]
@@ -1469,6 +1494,47 @@ class RGSXHandler(BaseHTTPRequestHandler):
                         'error': str(e)
                     }, status=500)
             
+            # Route: Sauvegarder seulement les filtres (sauvegarde rapide)
+            elif path == '/api/save_filters':
+                try:
+                    from rgsx_settings import load_rgsx_settings, save_rgsx_settings
+                    
+                    # Charger les settings actuels
+                    current_settings = load_rgsx_settings()
+                    
+                    # Mettre à jour seulement les filtres
+                    if 'game_filters' not in current_settings:
+                        current_settings['game_filters'] = {}
+                    
+                    current_settings['game_filters']['region_filters'] = data.get('region_filters', {})
+                    current_settings['game_filters']['hide_non_release'] = data.get('hide_non_release', False)
+                    current_settings['game_filters']['one_rom_per_game'] = data.get('one_rom_per_game', False)
+                    current_settings['game_filters']['regex_mode'] = data.get('regex_mode', False)
+                    current_settings['game_filters']['region_priority'] = data.get('region_priority', ['USA', 'Canada', 'World', 'Europe', 'Japan', 'Other'])
+                    
+                    # Sauvegarder
+                    save_rgsx_settings(current_settings)
+                    
+                    # Mettre à jour config.game_filter_obj
+                    if hasattr(config, 'game_filter_obj'):
+                        config.game_filter_obj.region_filters = data.get('region_filters', {})
+                        config.game_filter_obj.hide_non_release = data.get('hide_non_release', False)
+                        config.game_filter_obj.one_rom_per_game = data.get('one_rom_per_game', False)
+                        config.game_filter_obj.regex_mode = data.get('regex_mode', False)
+                        config.game_filter_obj.region_priority = data.get('region_priority', ['USA', 'Canada', 'World', 'Europe', 'Japan', 'Other'])
+                    
+                    self._send_json({
+                        'success': True,
+                        'message': 'Filtres sauvegardés'
+                    })
+                    
+                except Exception as e:
+                    logger.error(f"Erreur lors de la sauvegarde des filtres: {e}")
+                    self._send_json({
+                        'success': False,
+                        'error': str(e)
+                    }, status=500)
+            
             # Route: Vider l'historique
             elif path == '/api/clear-history':
                 try:

ports/RGSX/static/css/app.css

@@ -473,3 +473,70 @@ header p { opacity: 0.9; font-size: 1.1em; }
         padding: 3px 10px;
     }
 }
+
+/* Modal Support */
+.support-modal {
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background: rgba(0, 0, 0, 0.7);
+    display: flex;
+    justify-content: center;
+    align-items: center;
+    z-index: 10000;
+    animation: fadeIn 0.2s ease-out;
+}
+
+.support-modal-content {
+    background: #2c2c2c;
+    color: #ffffff;
+    padding: 30px;
+    border-radius: 12px;
+    max-width: 600px;
+    max-height: 80vh;
+    overflow-y: auto;
+    box-shadow: 0 8px 32px rgba(0,0,0,0.5);
+    position: relative;
+}
+
+.support-modal h2 {
+    margin: 0 0 20px 0;
+    color: #4CAF50;
+    font-size: 24px;
+}
+
+.support-modal-message {
+    white-space: pre-wrap;
+    line-height: 1.6;
+    margin-bottom: 25px;
+    color: #e0e0e0;
+}
+
+.support-modal button {
+    background: #4CAF50;
+    color: white;
+    border: none;
+    padding: 12px 30px;
+    border-radius: 6px;
+    cursor: pointer;
+    font-size: 16px;
+    font-weight: bold;
+    width: 100%;
+    transition: background 0.2s;
+}
+
+.support-modal button:hover {
+    background: #45a049;
+}
+
+@keyframes fadeIn {
+    from { opacity: 0; }
+    to { opacity: 1; }
+}
+
+@keyframes fadeOut {
+    from { opacity: 1; }
+    to { opacity: 0; }
+}

ports/RGSX/static/js/app.js

@@ -109,6 +109,53 @@
             document.head.appendChild(style);
         }
         
+        // Modal pour afficher les messages support avec formatage
+        function showSupportModal(title, message) {
+            // Remplacer les \n littéraux par de vrais retours à la ligne
+            message = message.replace(/\\n/g, '\n');
+            
+            // Créer la modal
+            const modal = document.createElement('div');
+            modal.className = 'support-modal';
+            
+            const modalContent = document.createElement('div');
+            modalContent.className = 'support-modal-content';
+            
+            // Titre
+            const titleElement = document.createElement('h2');
+            titleElement.textContent = title;
+            
+            // Message avec retours à la ligne préservés
+            const messageElement = document.createElement('div');
+            messageElement.className = 'support-modal-message';
+            messageElement.textContent = message;
+            
+            // Bouton OK
+            const okButton = document.createElement('button');
+            okButton.textContent = 'OK';
+            okButton.onclick = () => {
+                modal.style.animation = 'fadeOut 0.2s ease-in';
+                setTimeout(() => modal.remove(), 200);
+            };
+            
+            // Assembler la modal
+            modalContent.appendChild(titleElement);
+            modalContent.appendChild(messageElement);
+            modalContent.appendChild(okButton);
+            modal.appendChild(modalContent);
+            
+            // Ajouter au DOM
+            document.body.appendChild(modal);
+            
+            // Fermer en cliquant sur le fond
+            modal.onclick = (e) => {
+                if (e.target === modal) {
+                    modal.style.animation = 'fadeOut 0.2s ease-in';
+                    setTimeout(() => modal.remove(), 200);
+                }
+            };
+        }
+        
         // Charger les traductions au démarrage
         async function loadTranslations() {
             try {
@@ -309,6 +356,9 @@
         
         // Restaurer l'état depuis l'URL au chargement
         window.addEventListener('DOMContentLoaded', function() {
+            // Load saved filters first
+            loadSavedFilters();
+            
             const path = window.location.pathname;
             
             if (path.startsWith('/platform/')) {
@@ -478,9 +528,130 @@
         // Filter state: Map of region -> 'include' or 'exclude'
         let regionFilters = new Map();
         
+        // Checkbox filter states (stored globally to restore after page changes)
+        let savedHideNonRelease = false;
+        let savedOneRomPerGame = false;
+        let savedRegexMode = false;
+        
         // Region priority order for "One ROM Per Game" (customizable)
         let regionPriorityOrder = JSON.parse(localStorage.getItem('regionPriorityOrder')) || 
-            ['USA', 'Canada', 'World', 'Europe', 'Japan', 'Other'];
+            ['USA', 'Canada', 'Europe', 'France', 'Germany', 'Japan', 'Korea', 'World', 'Other'];
+        
+        // Save filters to backend
+        async function saveFiltersToBackend() {
+            try {
+                const regionFiltersObj = {};
+                regionFilters.forEach((mode, region) => {
+                    regionFiltersObj[region] = mode;
+                });
+                
+                // Update saved states from checkboxes if they exist
+                if (document.getElementById('hide-non-release')) {
+                    savedHideNonRelease = document.getElementById('hide-non-release').checked;
+                }
+                if (document.getElementById('one-rom-per-game')) {
+                    savedOneRomPerGame = document.getElementById('one-rom-per-game').checked;
+                }
+                if (document.getElementById('regex-mode')) {
+                    savedRegexMode = document.getElementById('regex-mode').checked;
+                }
+                
+                const response = await fetch('/api/save_filters', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        region_filters: regionFiltersObj,
+                        hide_non_release: savedHideNonRelease,
+                        one_rom_per_game: savedOneRomPerGame,
+                        regex_mode: savedRegexMode,
+                        region_priority: regionPriorityOrder
+                    })
+                });
+                
+                const data = await response.json();
+                if (!data.success) {
+                    console.warn('Failed to save filters:', data.error);
+                }
+            } catch (error) {
+                console.warn('Failed to save filters:', error);
+            }
+        }
+
+        // Load saved filters from settings
+        async function loadSavedFilters() {
+            try {
+                const response = await fetch('/api/settings');
+                const data = await response.json();
+                
+                if (data.success && data.settings.game_filters) {
+                    const filters = data.settings.game_filters;
+                    
+                    // Load region filters
+                    if (filters.region_filters) {
+                        regionFilters.clear();
+                        Object.entries(filters.region_filters).forEach(([region, mode]) => {
+                            regionFilters.set(region, mode);
+                        });
+                    }
+                    
+                    // Load region priority
+                    if (filters.region_priority) {
+                        regionPriorityOrder = filters.region_priority;
+                        localStorage.setItem('regionPriorityOrder', JSON.stringify(regionPriorityOrder));
+                    }
+                    
+                    // Save checkbox states to global variables
+                    savedHideNonRelease = filters.hide_non_release || false;
+                    savedOneRomPerGame = filters.one_rom_per_game || false;
+                    savedRegexMode = filters.regex_mode || false;
+                    
+                    // Load checkboxes when they exist (in games view)
+                    if (document.getElementById('hide-non-release')) {
+                        document.getElementById('hide-non-release').checked = savedHideNonRelease;
+                    }
+                    if (document.getElementById('one-rom-per-game')) {
+                        document.getElementById('one-rom-per-game').checked = savedOneRomPerGame;
+                    }
+                    if (document.getElementById('regex-mode')) {
+                        document.getElementById('regex-mode').checked = savedRegexMode;
+                    }
+                }
+            } catch (error) {
+                console.warn('Failed to load saved filters:', error);
+            }
+        }
+        
+        // Restore filter button states in the UI
+        function restoreFilterStates() {
+            // Restore region button states
+            regionFilters.forEach((mode, region) => {
+                const btn = document.querySelector(`.region-btn[data-region="${region}"]`);
+                if (btn) {
+                    if (mode === 'include') {
+                        btn.classList.add('active');
+                        btn.classList.remove('excluded');
+                    } else if (mode === 'exclude') {
+                        btn.classList.remove('active');
+                        btn.classList.add('excluded');
+                    }
+                }
+            });
+            
+            // Restore checkbox states
+            if (document.getElementById('hide-non-release')) {
+                document.getElementById('hide-non-release').checked = savedHideNonRelease;
+            }
+            if (document.getElementById('one-rom-per-game')) {
+                document.getElementById('one-rom-per-game').checked = savedOneRomPerGame;
+            }
+            if (document.getElementById('regex-mode')) {
+                document.getElementById('regex-mode').checked = savedRegexMode;
+            }
+            
+            // Apply filters to display the games correctly
+            applyAllFilters();
+        }
+
 
         // Helper: Extract region(s) from game name - returns array of regions
         function getGameRegions(gameName) {
@@ -490,12 +661,16 @@
             // Common region patterns - check all, not just first match
             // Handle both "(USA)" and "(USA, Europe)" formats
             if (name.includes('USA') || name.includes('US)')) regions.push('USA');
+            if (name.includes('CANADA')) regions.push('Canada');
             if (name.includes('EUROPE') || name.includes('EU)')) regions.push('Europe');
+            if (name.includes('FRANCE') || name.includes('FR)')) regions.push('France');
+            if (name.includes('GERMANY') || name.includes('DE)')) regions.push('Germany');
             if (name.includes('JAPAN') || name.includes('JP)') || name.includes('JPN)')) regions.push('Japan');
+            if (name.includes('KOREA') || name.includes('KR)')) regions.push('Korea');
             if (name.includes('WORLD')) regions.push('World');
             
-            // Check for other regions
-            if (name.match(/\b(AUSTRALIA|ASIA|KOREA|BRAZIL|CHINA|RUSSIA|SCANDINAVIA|SPAIN|FRANCE|GERMANY|ITALY)\b/)) {
+            // Check for other regions (excluding the ones above)
+            if (name.match(/\b(AUSTRALIA|ASIA|BRAZIL|CHINA|RUSSIA|SCANDINAVIA|SPAIN|ITALY)\b/)) {
                 if (!regions.includes('Other')) regions.push('Other');
             }
             
@@ -578,7 +753,10 @@
                 if (region === 'CANADA' && name.includes('CANADA')) return i;
                 if (region === 'WORLD' && name.includes('WORLD')) return i;
                 if (region === 'EUROPE' && (name.includes('EUROPE') || name.includes('EU)'))) return i;
+                if (region === 'FRANCE' && (name.includes('FRANCE') || name.includes('FR)'))) return i;
+                if (region === 'GERMANY' && (name.includes('GERMANY') || name.includes('DE)'))) return i;
                 if (region === 'JAPAN' && (name.includes('JAPAN') || name.includes('JP)') || name.includes('JPN)'))) return i;
+                if (region === 'KOREA' && (name.includes('KOREA') || name.includes('KR)'))) return i;
             }
             
             return regionPriorityOrder.length; // Other regions (lowest priority)
@@ -606,6 +784,7 @@
                 [regionPriorityOrder[idx-1], regionPriorityOrder[idx]];
                 saveRegionPriorityOrder();
                 renderRegionPriorityConfig();
+                saveFiltersToBackend();
             }
         }
         
@@ -617,14 +796,16 @@
                 [regionPriorityOrder[idx+1], regionPriorityOrder[idx]];
                 saveRegionPriorityOrder();
                 renderRegionPriorityConfig();
+                saveFiltersToBackend();
             }
         }
         
         // Reset region priority to default
         function resetRegionPriority() {
-            regionPriorityOrder = ['USA', 'Canada', 'World', 'Europe', 'Japan', 'Other'];
+            regionPriorityOrder = ['USA', 'Canada', 'Europe', 'France', 'Germany', 'Japan', 'Korea', 'World', 'Other'];
             saveRegionPriorityOrder();
             renderRegionPriorityConfig();
+            saveFiltersToBackend();
         }
         
         // Render region priority configuration UI
@@ -641,11 +822,11 @@
                         <span style="font-weight: bold; color: #666; min-width: 25px;">${idx + 1}.</span>
                         <span style="flex: 1; font-weight: 500;">${region}</span>
                         <button onclick="moveRegionUp('${region}')" 
-                                style="padding: 4px 8px; border: 1px solid #ccc; background: white; cursor: pointer; border-radius: 3px;"
-                                ${idx === 0 ? 'disabled' : ''}>▲</button>
+                                style="padding: 4px 8px; border: 1px solid #ccc; background: white; cursor: pointer; border-radius: 3px; font-size: 14px;"
+                                ${idx === 0 ? 'disabled' : ''}>🔼</button>
                         <button onclick="moveRegionDown('${region}')" 
-                                style="padding: 4px 8px; border: 1px solid #ccc; background: white; cursor: pointer; border-radius: 3px;"
-                                ${idx === regionPriorityOrder.length - 1 ? 'disabled' : ''}>▼</button>
+                                style="padding: 4px 8px; border: 1px solid #ccc; background: white; cursor: pointer; border-radius: 3px; font-size: 14px;"
+                                ${idx === regionPriorityOrder.length - 1 ? 'disabled' : ''}>🔽</button>
                     </div>
                 `;
             });
@@ -706,14 +887,15 @@
             }
 
             applyAllFilters();
+            saveFiltersToBackend();
         }
 
         // Apply all filters
         function applyAllFilters() {
             const searchInput = document.getElementById('game-search');
             const searchTerm = searchInput ? searchInput.value : '';
-            const hideNonRelease = document.getElementById('hide-non-release')?.checked || false;
-            const regexMode = document.getElementById('regex-mode')?.checked || false;
+            const hideNonRelease = document.getElementById('hide-non-release')?.checked || savedHideNonRelease;
+            const regexMode = document.getElementById('regex-mode')?.checked || savedRegexMode;
 
             const items = document.querySelectorAll('.game-item');
             let visibleCount = 0;
@@ -804,7 +986,7 @@
             });
 
             // Apply one-rom-per-game filter (after other filters)
-            const oneRomPerGame = document.getElementById('one-rom-per-game')?.checked || false;
+            const oneRomPerGame = document.getElementById('one-rom-per-game')?.checked || savedOneRomPerGame;
             if (oneRomPerGame) {
                 // Group currently visible games by base name
                 const gameGroups = new Map();
@@ -901,13 +1083,24 @@
                 const getSizeInMo = (sizeElem) => {
                     if (!sizeElem) return 0;
                     const text = sizeElem.textContent;
-                    // Les tailles sont maintenant normalisées: "100 Mo" ou "2.5 Go"
-                    const match = text.match(/([0-9.]+)\\s*(Mo|Go)/i);
+                    // Support des formats: "100 Mo", "2.5 Go" (français) et "100 MB", "2.5 GB" (anglais)
+                    // Plus Ko/KB, o/B, To/TB
+                    const match = text.match(/([0-9.]+)\s*(o|B|Ko|KB|Mo|MB|Go|GB|To|TB)/i);
                     if (!match) return 0;
                     let size = parseFloat(match[1]);
-                    // Convertir Go en Mo pour comparaison
-                    if (match[2].toUpperCase() === 'GO') {
-                        size *= 1024;
+                    const unit = match[2].toUpperCase();
+                    
+                    // Convertir tout en Mo
+                    if (unit === 'O' || unit === 'B') {
+                        size /= (1024 * 1024); // octets/bytes vers Mo
+                    } else if (unit === 'KO' || unit === 'KB') {
+                        size /= 1024; // Ko vers Mo
+                    } else if (unit === 'MO' || unit === 'MB') {
+                        // Déjà en Mo
+                    } else if (unit === 'GO' || unit === 'GB') {
+                        size *= 1024; // Go vers Mo
+                    } else if (unit === 'TO' || unit === 'TB') {
+                        size *= 1024 * 1024; // To vers Mo
                     }
                     return size;
                 };
@@ -1032,22 +1225,26 @@
                         <div class="filter-row">
                             <span class="filter-label">${t('web_filter_region')}:</span>
                             <button class="region-btn" data-region="USA" onclick="toggleRegionFilter('USA')"><img src="https://images.emojiterra.com/google/noto-emoji/unicode-16.0/color/svg/1f1fa-1f1f8.svg" style="width:16px;height:16px" /> USA</button>
-                            <button class="region-btn" data-region="Europe" onclick="toggleRegionFilter('Europe')"><img src="https://images.emojiterra.com/google/noto-emoji/unicode-16.0/color/svg/1f1ea-1f1fa.svg" style="width:16px;height:16px" /> Europe</button>                            
+                            <button class="region-btn" data-region="Canada" onclick="toggleRegionFilter('Canada')"><img src="https://images.emojiterra.com/google/noto-emoji/unicode-16.0/color/svg/1f1e8-1f1e6.svg" style="width:16px;height:16px" /> Canada</button>
+                            <button class="region-btn" data-region="Europe" onclick="toggleRegionFilter('Europe')"><img src="https://images.emojiterra.com/google/noto-emoji/unicode-16.0/color/svg/1f1ea-1f1fa.svg" style="width:16px;height:16px" /> Europe</button>
+                            <button class="region-btn" data-region="France" onclick="toggleRegionFilter('France')"><img src="https://images.emojiterra.com/google/noto-emoji/unicode-16.0/color/svg/1f1eb-1f1f7.svg" style="width:16px;height:16px" /> France</button>
+                            <button class="region-btn" data-region="Germany" onclick="toggleRegionFilter('Germany')"><img src="https://images.emojiterra.com/google/noto-emoji/unicode-16.0/color/svg/1f1e9-1f1ea.svg" style="width:16px;height:16px" /> Germany</button>
                             <button class="region-btn" data-region="Japan" onclick="toggleRegionFilter('Japan')"><img src="https://images.emojiterra.com/google/noto-emoji/unicode-16.0/color/svg/1f1ef-1f1f5.svg" style="width:16px;height:16px" /> Japan</button>
+                            <button class="region-btn" data-region="Korea" onclick="toggleRegionFilter('Korea')"><img src="https://images.emojiterra.com/google/noto-emoji/unicode-16.0/color/svg/1f1f0-1f1f7.svg" style="width:16px;height:16px" /> Korea</button>
                             <button class="region-btn" data-region="World" onclick="toggleRegionFilter('World')">🌍 World</button>
                             <button class="region-btn" data-region="Other" onclick="toggleRegionFilter('Other')">🌐 Other</button>
                         </div>
                         <div class="filter-row">
                             <label class="filter-checkbox">
-                                <input type="checkbox" id="hide-non-release" onchange="applyAllFilters()">
+                                <input type="checkbox" id="hide-non-release" onchange="applyAllFilters(); saveFiltersToBackend();">
                                 <span>${t('web_filter_hide_non_release')}</span>
                             </label>
                             <label class="filter-checkbox">
-                                <input type="checkbox" id="regex-mode" onchange="applyAllFilters()">
+                                <input type="checkbox" id="regex-mode" onchange="applyAllFilters(); saveFiltersToBackend();">
                                 <span>${t('web_filter_regex_mode')}</span>
                             </label>
                             <label class="filter-checkbox">
-                                <input type="checkbox" id="one-rom-per-game" onchange="applyAllFilters()">
+                                <input type="checkbox" id="one-rom-per-game" onchange="applyAllFilters(); saveFiltersToBackend();">
                                 <span>${t('web_filter_one_rom_per_game')} (<span id="region-priority-display">USA → Canada → World → Europe → Japan → Other</span>)</span>
                                 <button onclick="showRegionPriorityConfig()" style="margin-left: 8px; padding: 2px 8px; font-size: 0.9em; background: #666; color: white; border: none; border-radius: 3px; cursor: pointer;" title="${t('web_filter_configure_priority')}">⚙️</button>
                             </label>
@@ -1082,6 +1279,9 @@
                 `;
                 container.innerHTML = html;
                 
+                // Restore filter states from loaded settings
+                restoreFilterStates();
+                
                 // Appliquer le tri par défaut (A-Z)
                 sortGames(currentGameSort);
                 
@@ -1902,6 +2102,12 @@
             }
             
             try {
+                // Collect region filters
+                const regionFiltersObj = {};
+                regionFilters.forEach((mode, region) => {
+                    regionFiltersObj[region] = mode;
+                });
+                
                 const settings = {
                     language: document.getElementById('setting-language').value,
                     music_enabled: document.getElementById('setting-music').checked,
@@ -1921,7 +2127,14 @@
                     },
                     show_unsupported_platforms: document.getElementById('setting-show-unsupported').checked,
                     allow_unknown_extensions: document.getElementById('setting-allow-unknown').checked,
-                    roms_folder: document.getElementById('setting-roms-folder').value.trim()
+                    roms_folder: document.getElementById('setting-roms-folder').value.trim(),
+                    game_filters: {
+                        region_filters: regionFiltersObj,
+                        hide_non_release: document.getElementById('hide-non-release')?.checked || savedHideNonRelease,
+                        one_rom_per_game: document.getElementById('one-rom-per-game')?.checked || savedOneRomPerGame,
+                        regex_mode: document.getElementById('regex-mode')?.checked || savedRegexMode,
+                        region_priority: regionPriorityOrder
+                    }
                 };
                 
                 const response = await fetch('/api/settings', {
@@ -2020,7 +2233,7 @@
         }
         
         // Générer un fichier ZIP de support
-        async function generateSupportZip() {
+        async function generateSupportZip(event) {
             try {
                 // Afficher un message de chargement
                 const loadingMsg = t('web_support_generating');
@@ -2063,8 +2276,8 @@
                 window.URL.revokeObjectURL(url);
                 document.body.removeChild(a);
                 
-                // Afficher le message d'instructions
-                alert(t('web_support_title') + '\\n\\n' + t('web_support_message'));
+                // Afficher le message d'instructions dans une modal
+                showSupportModal(t('web_support_title'), t('web_support_message'));
                 
                 // Restaurer le bouton
                 if (originalButton) {

ports/RGSX/utils.py

@@ -1294,6 +1294,18 @@ def _handle_special_platforms(dest_dir, archive_path, before_dirs, iso_before=No
         if not success:
             return False, error_msg
     
+    # PSVita: extraction dans ux0/app + création fichier .psvita
+    psvita_dir_normal = os.path.join(config.ROMS_FOLDER, "psvita")
+    psvita_dir_symlink = os.path.join(config.ROMS_FOLDER, "psvita", "psvita")
+    is_psvita = (dest_dir == psvita_dir_normal or dest_dir == psvita_dir_symlink)
+    
+    if is_psvita:
+        expected_base = os.path.splitext(os.path.basename(archive_path))[0]
+        items_before = before_items if before_items is not None else before_dirs
+        success, error_msg = handle_psvita(dest_dir, items_before, extracted_basename=expected_base)
+        if not success:
+            return False, error_msg
+    
     return True, None
 
 def extract_zip(zip_path, dest_dir, url):
@@ -1959,6 +1971,136 @@ def handle_scummvm(dest_dir, before_items, extracted_basename=None):
         return False, error_msg
 
 
+def handle_psvita(dest_dir, before_items, extracted_basename=None):
+    """Gère l'organisation spécifique des jeux PSVita extraits.
+    
+    Structure attendue:
+    - Archive RAR extraite → Dossier "Nom du jeu"/
+    - Dans ce dossier → Fichier "IDJeu.zip" (ex: PCSE00890.zip)
+    - Ce ZIP contient → Dossier "IDJeu" (ex: PCSE00890/)
+    
+    Actions:
+    1. Créer fichier "Nom du jeu [IDJeu].psvita" dans dest_dir
+    2. Extraire IDJeu.zip dans config.SAVE_FOLDER/psvita/ux0/app/
+    3. Supprimer le dossier temporaire "Nom du jeu"/
+    
+    Args:
+        dest_dir: Dossier de destination (psvita ou psvita/psvita)
+        before_items: Set des éléments présents avant extraction
+        extracted_basename: Nom de base de l'archive extraite (sans extension)
+    """
+    logger.debug(f"Traitement spécifique PSVita dans: {dest_dir}")
+    time.sleep(2)  # Petite latence post-extraction
+    
+    try:
+        after_items = set(os.listdir(dest_dir))
+    except Exception:
+        after_items = set()
+    
+    ignore_names = {"psvita", "images", "videos", "manuals", "media"}
+    # Filtrer les nouveaux éléments (fichiers ou dossiers)
+    new_items = [item for item in (after_items - before_items) 
+                 if item not in ignore_names and not item.endswith('.psvita')]
+    
+    if not new_items:
+        logger.warning("PSVita: Aucun nouveau dossier détecté après extraction")
+        return True, None
+    
+    if not extracted_basename:
+        extracted_basename = new_items[0] if new_items else "game"
+    
+    # Chercher le dossier du jeu (normalement il n'y en a qu'un)
+    game_folder = None
+    for item in new_items:
+        item_path = os.path.join(dest_dir, item)
+        if os.path.isdir(item_path):
+            game_folder = item
+            game_folder_path = item_path
+            break
+    
+    if not game_folder:
+        logger.error("PSVita: Aucun dossier de jeu trouvé après extraction")
+        return False, "PSVita: Aucun dossier de jeu trouvé"
+    
+    logger.debug(f"PSVita: Dossier de jeu trouvé: {game_folder}")
+    
+    # Chercher le fichier ZIP à l'intérieur (IDJeu.zip)
+    try:
+        contents = os.listdir(game_folder_path)
+        zip_files = [f for f in contents if f.lower().endswith('.zip')]
+        
+        if not zip_files:
+            logger.error(f"PSVita: Aucun fichier ZIP trouvé dans {game_folder}")
+            return False, f"PSVita: Aucun ZIP trouvé dans {game_folder}"
+        
+        # Prendre le premier ZIP trouvé
+        zip_filename = zip_files[0]
+        zip_path = os.path.join(game_folder_path, zip_filename)
+        
+        # Extraire l'ID du jeu (nom du ZIP sans extension)
+        game_id = os.path.splitext(zip_filename)[0]
+        logger.debug(f"PSVita: ZIP trouvé: {zip_filename}, ID du jeu: {game_id}")
+        
+        # 1. Créer le fichier .psvita dans dest_dir
+        psvita_filename = f"{game_folder} [{game_id}].psvita"
+        psvita_file_path = os.path.join(dest_dir, psvita_filename)
+        
+        try:
+            # Créer un fichier vide .psvita
+            with open(psvita_file_path, 'w', encoding='utf-8') as f:
+                f.write(f"# PSVita Game\n")
+                f.write(f"# Game: {game_folder}\n")
+                f.write(f"# ID: {game_id}\n")
+            logger.info(f"PSVita: Fichier .psvita créé: {psvita_filename}")
+        except Exception as e:
+            logger.error(f"PSVita: Erreur création fichier .psvita: {e}")
+            return False, f"Erreur création {psvita_filename}: {e}"
+        
+        # 2. Extraire le ZIP dans le dossier parent de config.SAVE_FOLDER/psvita/ux0/app/
+        save_parent2 = os.path.dirname(config.SAVE_FOLDER)
+        save_parent = os.path.dirname(save_parent2)
+        ux0_app_dir = os.path.join(save_parent, "psvita", "ux0", "app")
+        os.makedirs(ux0_app_dir, exist_ok=True)
+        
+        logger.debug(f"PSVita: Extraction de {zip_filename} dans {ux0_app_dir}")
+        
+        try:
+            import zipfile
+            with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+                zip_ref.extractall(ux0_app_dir)
+            logger.info(f"PSVita: ZIP extrait avec succès dans {ux0_app_dir}")
+            
+            # Vérifier que le dossier game_id existe bien
+            game_id_path = os.path.join(ux0_app_dir, game_id)
+            if not os.path.exists(game_id_path):
+                logger.warning(f"PSVita: Le dossier {game_id} n'a pas été trouvé dans l'extraction")
+            else:
+                logger.info(f"PSVita: Dossier {game_id} confirmé dans ux0/app/")
+        
+        except zipfile.BadZipFile as e:
+            logger.error(f"PSVita: Fichier ZIP corrompu: {e}")
+            return False, f"ZIP corrompu: {zip_filename}"
+        except Exception as e:
+            logger.error(f"PSVita: Erreur extraction ZIP: {e}")
+            return False, f"Erreur extraction {zip_filename}: {e}"
+        
+        # 3. Supprimer le dossier temporaire du jeu
+        try:
+            import shutil
+            shutil.rmtree(game_folder_path)
+            logger.info(f"PSVita: Dossier temporaire supprimé: {game_folder}")
+        except Exception as e:
+            logger.warning(f"PSVita: Impossible de supprimer {game_folder}: {e}")
+            # Ne pas échouer pour ça, le jeu est quand même installé
+        
+        logger.info(f"PSVita: Traitement terminé avec succès - {psvita_filename} créé, {game_id} installé dans ux0/app/")
+        return True, None
+        
+    except Exception as e:
+        logger.error(f"PSVita: Erreur générale: {e}", exc_info=True)
+        return False, f"Erreur PSVita: {str(e)}"
+
+
 def handle_xbox(dest_dir, iso_files, url=None):
     """Gère la conversion des fichiers Xbox extraits et met à jour l'UI (Converting)."""
     logger.debug(f"Traitement spécifique Xbox dans: {dest_dir}")

version.json

@@ -1,3 +1,3 @@
 {
-    "version": "2.3.2.6"
+    "version": "2.3.3.1"
 }