manga_settings_dialog.py

# manga_settings_dialog.py
"""
Enhanced settings dialog for manga translation with all settings visible
Properly integrated with TranslatorGUI's WindowManager and UIHelper
"""

import os
import json
import tkinter as tk
from tkinter import ttk, filedialog, messagebox
import ttkbootstrap as tb
from typing import Dict, Any, Optional, Callable
from bubble_detector import BubbleDetector
import logging
import time
import copy

# Use the same logging infrastructure initialized by translator_gui
logger = logging.getLogger(__name__)

class MangaSettingsDialog:
    """Settings dialog for manga translation"""
    
    def __init__(self, parent, main_gui, config: Dict[str, Any], callback: Optional[Callable] = None):
        """Initialize settings dialog
        
        Args:
            parent: Parent window
            main_gui: Reference to TranslatorGUI instance
            config: Configuration dictionary
            callback: Function to call after saving
        """
        self.parent = parent
        self.main_gui = main_gui
        self.config = config
        self.callback = callback
        self.dialog = None
        
        # Enhanced default settings structure with all options
        self.default_settings = {
            'preprocessing': {
                'enabled': False,
                'auto_detect_quality': True,
                'contrast_threshold': 0.4,
                'sharpness_threshold': 0.3,
                'noise_threshold': 20,
                'enhancement_strength': 1.5,
                'denoise_strength': 10,
                'max_image_dimension': 2000,
                'max_image_pixels': 2000000,
                'chunk_height': 2000,
                'chunk_overlap': 100,
                # Inpainting tiling
                'inpaint_tiling_enabled': False,  # Off by default
                'inpaint_tile_size': 512,  # Default tile size
                'inpaint_tile_overlap': 64  # Overlap to avoid seams
            },
            'compression': {
                'enabled': False,
                'format': 'jpeg',
                'jpeg_quality': 85,
                'png_compress_level': 6,
                'webp_quality': 85
            },
'ocr': {
                'language_hints': ['ja', 'ko', 'zh'],
                'confidence_threshold': 0.7,
                'merge_nearby_threshold': 20,
                'azure_merge_multiplier': 3.0,
                'text_detection_mode': 'document',
                'enable_rotation_correction': True,
                'bubble_detection_enabled': True,
                'roi_locality_enabled': False,
                'bubble_model_path': '',
                'bubble_confidence': 0.5,
                'detector_type': 'rtdetr_onnx',
                'rtdetr_confidence': 0.3,
                'detect_empty_bubbles': True,
                'detect_text_bubbles': True,
                'detect_free_text': True,
                'rtdetr_model_url': '',
                'azure_reading_order': 'natural',
                'azure_model_version': 'latest',
                'azure_max_wait': 60,
                'azure_poll_interval': 0.5,
                'min_text_length': 0,
                'exclude_english_text': False,
                'english_exclude_threshold': 0.7,
                'english_exclude_min_chars': 4,
                'english_exclude_short_tokens': False
            },
            'advanced': {
                'format_detection': True,
                'webtoon_mode': 'auto',
                'debug_mode': False,
                'save_intermediate': False,
                'parallel_processing': True,
                'max_workers': 2,
                'parallel_panel_translation': False,
                'panel_max_workers': 2,
                'use_singleton_models': False,
                'auto_cleanup_models': False,
                'unload_models_after_translation': False,
                'auto_convert_to_onnx': False,  # Disabled by default
                'auto_convert_to_onnx_background': True,
                'quantize_models': False,
                'onnx_quantize': False,
                'torch_precision': 'fp16',
                # HD strategy defaults (mirrors comic-translate)
                'hd_strategy': 'resize',                # 'original' | 'resize' | 'crop'
                'hd_strategy_resize_limit': 1536,       # long-edge cap for resize
                'hd_strategy_crop_margin': 16,          # pixels padding around cropped ROIs
                'hd_strategy_crop_trigger_size': 1024,  # only crop if long edge exceeds this
                # RAM cap defaults
                'ram_cap_enabled': False,
                'ram_cap_mb': 4096,
                'ram_cap_mode': 'soft',
                'ram_gate_timeout_sec': 15.0,
                'ram_min_floor_over_baseline_mb': 256
                },
            'inpainting': {
                'batch_size': 10,
                'enable_cache': True,
                'method': 'local',
                'local_method': 'anime'
            },
            'font_sizing': {
            'algorithm': 'smart',  # 'smart', 'conservative', 'aggressive'
            'prefer_larger': True,  # Prefer larger readable text
            'max_lines': 10,  # Maximum lines before forcing smaller
            'line_spacing': 1.3,  # Line height multiplier
            'bubble_size_factor': True  # Scale font based on bubble size
            },
            
            # Mask dilation settings with new iteration controls
            'mask_dilation': 0,
            'use_all_iterations': True,  # Master control - use same for all by default
            'all_iterations': 2,  # Value when using same for all
            'text_bubble_dilation_iterations': 2,  # Text-filled speech bubbles
            'empty_bubble_dilation_iterations': 3,  # Empty speech bubbles
            'free_text_dilation_iterations': 0,  # Free text (0 for clean B&W)
            'bubble_dilation_iterations': 2,  # Legacy support
            'dilation_iterations': 2,  # Legacy support
            
            # Cloud inpainting settings
            'cloud_inpaint_model': 'ideogram-v2',
            'cloud_custom_version': '',
            'cloud_inpaint_prompt': 'clean background, smooth surface',
            'cloud_negative_prompt': 'text, writing, letters',
            'cloud_inference_steps': 20,
            'cloud_timeout': 60
        }
        
        # Merge with existing config
        self.settings = self._merge_settings(config.get('manga_settings', {}))
        
        # Show dialog
        self.show_dialog()
            
    def _disable_spinbox_scroll(self, widget):
        """Disable mouse wheel scrolling on a spinbox or combobox"""
        def dummy_scroll(event):
            # Return "break" to prevent the default scroll behavior
            return "break"
        
        # Bind mouse wheel events to the dummy handler
        widget.bind("<MouseWheel>", dummy_scroll)  # Windows
        widget.bind("<Button-4>", dummy_scroll)    # Linux scroll up
        widget.bind("<Button-5>", dummy_scroll)    # Linux scroll down

    def _disable_all_spinbox_scrolling(self, parent):
        """Recursively find and disable scrolling on all spinboxes and comboboxes"""
        for widget in parent.winfo_children():
            # Check if it's a Spinbox (both ttk and tk versions)
            if isinstance(widget, (tb.Spinbox, tk.Spinbox, ttk.Spinbox)):
                self._disable_spinbox_scroll(widget)
            # Check if it's a Combobox (ttk and ttkbootstrap versions)
            elif isinstance(widget, (ttk.Combobox, tb.Combobox)):
                self._disable_spinbox_scroll(widget)
            # Recursively check frames and other containers
            elif hasattr(widget, 'winfo_children'):
                self._disable_all_spinbox_scrolling(widget)
            
    def _create_font_size_controls(self, parent_frame):
        """Create improved font size controls with presets"""
        
        # Font size frame
        font_frame = tk.Frame(parent_frame)
        font_frame.pack(fill=tk.X, pady=5)
        
        tk.Label(font_frame, text="Font Size:", width=20, anchor='w').pack(side=tk.LEFT)
        
        # Font size mode selection
        mode_frame = tk.Frame(font_frame)
        mode_frame.pack(side=tk.LEFT, padx=10)
        
        # Radio buttons for mode
        self.font_size_mode_var = tk.StringVar(value='auto')
        
        modes = [
            ("Auto", "auto", "Automatically fit text to bubble size"),
            ("Fixed", "fixed", "Use a specific font size"),
            ("Scale", "scale", "Scale auto size by percentage")
        ]
        
        for text, value, tooltip in modes:
            rb = ttk.Radiobutton(
                mode_frame,
                text=text,
                variable=self.font_size_mode_var,
                value=value,
                command=self._on_font_mode_change
            )
            rb.pack(side=tk.LEFT, padx=5)
            
            # Add tooltip
            self._create_tooltip(rb, tooltip)
        
        # Controls frame (changes based on mode)
        self.font_controls_frame = tk.Frame(parent_frame)
        self.font_controls_frame.pack(fill=tk.X, pady=5, padx=(20, 0))
        
        # Fixed size controls
        self.fixed_size_frame = tk.Frame(self.font_controls_frame)
        tk.Label(self.fixed_size_frame, text="Size:").pack(side=tk.LEFT)
        
        self.fixed_font_size_var = tk.IntVar(value=16)
        fixed_spin = tb.Spinbox(
            self.fixed_size_frame,
            from_=8,
            to=72,
            textvariable=self.fixed_font_size_var,
            width=10,
            command=self._save_rendering_settings
        )
        fixed_spin.pack(side=tk.LEFT, padx=5)
        
        # Quick presets for fixed size
        tk.Label(self.fixed_size_frame, text="Presets:").pack(side=tk.LEFT, padx=(10, 5))
        
        presets = [
            ("Small", 12),
            ("Medium", 16),
            ("Large", 20),
            ("XL", 24)
        ]
        
        for text, size in presets:
            ttk.Button(
                self.fixed_size_frame,
                text=text,
                command=lambda s=size: self._set_fixed_size(s),
                width=6
            ).pack(side=tk.LEFT, padx=2)
        
        # Scale controls
        self.scale_frame = tk.Frame(self.font_controls_frame)
        tk.Label(self.scale_frame, text="Scale:").pack(side=tk.LEFT)
        
        self.font_scale_var = tk.DoubleVar(value=1.0)
        scale_slider = tk.Scale(
            self.scale_frame,
            from_=0.5,
            to=2.0,
            resolution=0.01,
            orient=tk.HORIZONTAL,
            variable=self.font_scale_var,
            length=200,
            command=lambda v: self._update_scale_label()
        )
        scale_slider.pack(side=tk.LEFT, padx=5)
        
        self.scale_label = tk.Label(self.scale_frame, text="100%", width=5)
        self.scale_label.pack(side=tk.LEFT)
        
        # Quick scale presets
        tk.Label(self.scale_frame, text="Quick:").pack(side=tk.LEFT, padx=(10, 5))
        
        scale_presets = [
            ("75%", 0.75),
            ("100%", 1.0),
            ("125%", 1.25),
            ("150%", 1.5)
        ]
        
        for text, scale in scale_presets:
            ttk.Button(
                self.scale_frame,
                text=text,
                command=lambda s=scale: self._set_scale(s),
                width=5
            ).pack(side=tk.LEFT, padx=2)
        
        # Auto size settings
        self.auto_frame = tk.Frame(self.font_controls_frame)
        
        # Min/Max size constraints for auto mode
        constraints_frame = tk.Frame(self.auto_frame)
        constraints_frame.pack(fill=tk.X)
        
        tk.Label(constraints_frame, text="Size Range:").pack(side=tk.LEFT)
        
        tk.Label(constraints_frame, text="Min:").pack(side=tk.LEFT, padx=(10, 2))
        self.min_font_size_var = tk.IntVar(value=10)
        tb.Spinbox(
            constraints_frame,
            from_=6,
            to=20,
            textvariable=self.min_font_size_var,
            width=8,
            command=self._save_rendering_settings
        ).pack(side=tk.LEFT)
        
        tk.Label(constraints_frame, text="Max:").pack(side=tk.LEFT, padx=(10, 2))
        self.max_font_size_var = tk.IntVar(value=28)
        tb.Spinbox(
            constraints_frame,
            from_=16,
            to=48,
            textvariable=self.max_font_size_var,
            width=8,
            command=self._save_rendering_settings
        ).pack(side=tk.LEFT)
        
        # Auto fit quality
        quality_frame = tk.Frame(self.auto_frame)
        quality_frame.pack(fill=tk.X, pady=(5, 0))
        
        tk.Label(quality_frame, text="Fit Style:").pack(side=tk.LEFT)
        
        self.auto_fit_style_var = tk.StringVar(value='balanced')
        
        fit_styles = [
            ("Compact", "compact", "Fit more text, smaller size"),
            ("Balanced", "balanced", "Balance readability and fit"),
            ("Readable", "readable", "Prefer larger, more readable text")
        ]
        
        for text, value, tooltip in fit_styles:
            rb = ttk.Radiobutton(
                quality_frame,
                text=text,
                variable=self.auto_fit_style_var,
                value=value,
                command=self._save_rendering_settings
            )
            rb.pack(side=tk.LEFT, padx=5)
            self._create_tooltip(rb, tooltip)
        
        # Initialize the correct frame
        self._on_font_mode_change()

    def _on_font_mode_change(self):
        """Show/hide appropriate font controls based on mode"""
        # Hide all frames
        for frame in [self.fixed_size_frame, self.scale_frame, self.auto_frame]:
            frame.pack_forget()
        
        # Show the appropriate frame
        mode = self.font_size_mode_var.get()
        if mode == 'fixed':
            self.fixed_size_frame.pack(fill=tk.X)
        elif mode == 'scale':
            self.scale_frame.pack(fill=tk.X)
        else:  # auto
            self.auto_frame.pack(fill=tk.X)
        
        self._save_rendering_settings()

    def _set_fixed_size(self, size):
        """Set fixed font size from preset"""
        self.fixed_font_size_var.set(size)
        self._save_rendering_settings()

    def _set_scale(self, scale):
        """Set font scale from preset"""
        self.font_scale_var.set(scale)
        self._update_scale_label()
        self._save_rendering_settings()

    def _update_scale_label(self):
        """Update the scale percentage label"""
        scale = self.font_scale_var.get()
        self.scale_label.config(text=f"{int(scale * 100)}%")
        self._save_rendering_settings()

    def _create_tooltip(self, widget, text):
        """Create a tooltip for a widget"""
        def on_enter(event):
            tooltip = tk.Toplevel()
            tooltip.wm_overrideredirect(True)
            tooltip.wm_geometry(f"+{event.x_root+10}+{event.y_root+10}")
            
            label = tk.Label(
                tooltip,
                text=text,
                background="#ffffe0",
                relief=tk.SOLID,
                borderwidth=1,
                font=('Arial', 9)
            )
            label.pack()
            
            widget.tooltip = tooltip
        
        def on_leave(event):
            if hasattr(widget, 'tooltip'):
                widget.tooltip.destroy()
                del widget.tooltip
        
        widget.bind('<Enter>', on_enter)
        widget.bind('<Leave>', on_leave)
    
    def _merge_settings(self, existing: Dict) -> Dict:
        """Merge existing settings with defaults"""
        result = self.default_settings.copy()
        
        def deep_merge(base: Dict, update: Dict) -> Dict:
            for key, value in update.items():
                if key in base and isinstance(base[key], dict) and isinstance(value, dict):
                    base[key] = deep_merge(base[key], value)
                else:
                    base[key] = value
            return base
        
        return deep_merge(result, existing)
    
    def show_dialog(self):
        """Display the settings dialog using WindowManager"""
        # Set initialization flag to prevent auto-saves during setup
        self._initializing = True
        
        # Use WindowManager to create scrollable dialog
        if self.main_gui.wm._force_safe_ratios:
            max_width_ratio = 0.5
            max_height_ratio = 0.85
        else:
            max_width_ratio = 0.5
            max_height_ratio = 1.05
            
        self.dialog, scrollable_frame, canvas = self.main_gui.wm.setup_scrollable(
            self.parent,
            "Manga Translation Settings",
            width=None,
            height=None,
            max_width_ratio=max_width_ratio,
            max_height_ratio=max_height_ratio 
        )
        
        # Store canvas reference for potential cleanup
        self.canvas = canvas
        
        # Create main content frame (that will scroll)
        content_frame = tk.Frame(scrollable_frame)
        content_frame.pack(fill='both', expand=True, padx=10, pady=10)
        
        # Create notebook for tabs inside the content frame
        notebook = ttk.Notebook(content_frame)
        notebook.pack(fill='both', expand=True)
        
        # Create all tabs
        self._create_preprocessing_tab(notebook)
        self._create_ocr_tab(notebook)
        self._create_inpainting_tab(notebook)
        self._create_advanced_tab(notebook)
        # NOTE: Font Sizing tab removed; controls are now in Manga Integration UI
        
        # Cloud API tab
        self.cloud_tab = ttk.Frame(notebook)
        notebook.add(self.cloud_tab, text="Cloud API")
        self._create_cloud_api_tab(self.cloud_tab)
        
        # DISABLE SCROLL WHEEL ON ALL SPINBOXES
        self.dialog.after(10, lambda: self._disable_all_spinbox_scrolling(self.dialog))
        
        # Clear initialization flag after setup is complete
        self._initializing = False
        
        # Create fixed button frame at bottom of dialog (not inside scrollable content)
        button_frame = tk.Frame(self.dialog)
        button_frame.pack(fill='x', padx=10, pady=(5, 10), side='bottom')
        
        # Buttons
        tb.Button(
            button_frame,
            text="Save",
            command=self._save_settings,
            bootstyle="success"
        ).pack(side='right', padx=(5, 0))
        
        tb.Button(
            button_frame,
            text="Cancel",
            command=self._cancel,
            bootstyle="secondary"
        ).pack(side='right', padx=(5, 0))
        
        tb.Button(
            button_frame,
            text="Reset to Defaults",
            command=self._reset_defaults,
            bootstyle="warning"
        ).pack(side='left')
        
        # Initialize preprocessing state
        self._toggle_preprocessing()
        
        # Handle window close protocol
        self.dialog.protocol("WM_DELETE_WINDOW", self._cancel)
    
    def _create_preprocessing_tab(self, notebook):
        """Create preprocessing settings tab with all options"""
        frame = ttk.Frame(notebook)
        notebook.add(frame, text="Preprocessing")
        
        # Main scrollable content
        content_frame = tk.Frame(frame)
        content_frame.pack(fill='both', expand=True, padx=5, pady=5)
        
        # Enable preprocessing with command
        enable_frame = tk.Frame(content_frame)
        enable_frame.pack(fill='x', padx=20, pady=(20, 10))
        
        self.preprocess_enabled = tk.BooleanVar(value=self.settings['preprocessing']['enabled'])
        tb.Checkbutton(
            enable_frame,
            text="Enable Image Preprocessing",
            variable=self.preprocess_enabled,
            bootstyle="round-toggle",
            command=self._toggle_preprocessing 
        ).pack(anchor='w')
        
        # Store all preprocessing controls for enable/disable
        self.preprocessing_controls = []
        
        # Auto quality detection
        self.auto_detect = tk.BooleanVar(value=self.settings['preprocessing']['auto_detect_quality'])
        auto_cb = tb.Checkbutton(
            enable_frame,
            text="Auto-detect image quality issues",
            variable=self.auto_detect,
            bootstyle="round-toggle"
        )
        auto_cb.pack(anchor='w', pady=(10, 0))
        self.preprocessing_controls.append(auto_cb)
        
        # Quality thresholds section
        threshold_frame = tk.LabelFrame(content_frame, text="Image Enhancement", padx=15, pady=10)
        threshold_frame.pack(fill='x', padx=20, pady=(10, 0))
        self.preprocessing_controls.append(threshold_frame)
        
        # Contrast threshold
        contrast_frame = tk.Frame(threshold_frame)
        contrast_frame.pack(fill='x', pady=5)
        contrast_label = tk.Label(contrast_frame, text="Contrast Adjustment:", width=20, anchor='w')
        contrast_label.pack(side='left')
        self.preprocessing_controls.append(contrast_label)
        
        self.contrast_threshold = tk.DoubleVar(value=self.settings['preprocessing']['contrast_threshold'])
        contrast_scale = tk.Scale(
            contrast_frame,
            from_=0.0, to=1.0,
            resolution=0.01,
            orient='horizontal',
            variable=self.contrast_threshold,
            length=250
        )
        contrast_scale.pack(side='left', padx=10)
        self.preprocessing_controls.append(contrast_scale)
        
        contrast_value = tk.Label(contrast_frame, textvariable=self.contrast_threshold, width=5)
        contrast_value.pack(side='left')
        self.preprocessing_controls.append(contrast_value)
        
        # Sharpness threshold
        sharpness_frame = tk.Frame(threshold_frame)
        sharpness_frame.pack(fill='x', pady=5)
        sharpness_label = tk.Label(sharpness_frame, text="Sharpness Enhancement:", width=20, anchor='w')
        sharpness_label.pack(side='left')
        self.preprocessing_controls.append(sharpness_label)
        
        self.sharpness_threshold = tk.DoubleVar(value=self.settings['preprocessing']['sharpness_threshold'])
        sharpness_scale = tk.Scale(
            sharpness_frame,
            from_=0.0, to=1.0,
            resolution=0.01,
            orient='horizontal',
            variable=self.sharpness_threshold,
            length=250
        )
        sharpness_scale.pack(side='left', padx=10)
        self.preprocessing_controls.append(sharpness_scale)
        
        sharpness_value = tk.Label(sharpness_frame, textvariable=self.sharpness_threshold, width=5)
        sharpness_value.pack(side='left')
        self.preprocessing_controls.append(sharpness_value)
        
        # Enhancement strength
        enhance_frame = tk.Frame(threshold_frame)
        enhance_frame.pack(fill='x', pady=5)
        enhance_label = tk.Label(enhance_frame, text="Overall Enhancement:", width=20, anchor='w')
        enhance_label.pack(side='left')
        self.preprocessing_controls.append(enhance_label)
        
        self.enhancement_strength = tk.DoubleVar(value=self.settings['preprocessing']['enhancement_strength'])
        enhance_scale = tk.Scale(
            enhance_frame,
            from_=0.0, to=3.0,
            resolution=0.01,
            orient='horizontal',
            variable=self.enhancement_strength,
            length=250
        )
        enhance_scale.pack(side='left', padx=10)
        self.preprocessing_controls.append(enhance_scale)
        
        enhance_value = tk.Label(enhance_frame, textvariable=self.enhancement_strength, width=5)
        enhance_value.pack(side='left')
        self.preprocessing_controls.append(enhance_value)
        
        # Noise reduction section
        noise_frame = tk.LabelFrame(content_frame, text="Noise Reduction", padx=15, pady=10)
        noise_frame.pack(fill='x', padx=20, pady=(10, 0))
        self.preprocessing_controls.append(noise_frame)
        
        # Noise threshold
        noise_threshold_frame = tk.Frame(noise_frame)
        noise_threshold_frame.pack(fill='x', pady=5)
        noise_label = tk.Label(noise_threshold_frame, text="Noise Threshold:", width=20, anchor='w')
        noise_label.pack(side='left')
        self.preprocessing_controls.append(noise_label)
        
        self.noise_threshold = tk.IntVar(value=self.settings['preprocessing']['noise_threshold'])
        noise_scale = tk.Scale(
            noise_threshold_frame,
            from_=0, to=50,
            orient='horizontal',
            variable=self.noise_threshold,
            length=250
        )
        noise_scale.pack(side='left', padx=10)
        self.preprocessing_controls.append(noise_scale)
        
        noise_value = tk.Label(noise_threshold_frame, textvariable=self.noise_threshold, width=5)
        noise_value.pack(side='left')
        self.preprocessing_controls.append(noise_value)
        
        # Denoise strength
        denoise_frame = tk.Frame(noise_frame)
        denoise_frame.pack(fill='x', pady=5)
        denoise_label = tk.Label(denoise_frame, text="Denoise Strength:", width=20, anchor='w')
        denoise_label.pack(side='left')
        self.preprocessing_controls.append(denoise_label)
        
        self.denoise_strength = tk.IntVar(value=self.settings['preprocessing']['denoise_strength'])
        denoise_scale = tk.Scale(
            denoise_frame,
            from_=0, to=30,
            orient='horizontal',
            variable=self.denoise_strength,
            length=250
        )
        denoise_scale.pack(side='left', padx=10)
        self.preprocessing_controls.append(denoise_scale)
        
        denoise_value = tk.Label(denoise_frame, textvariable=self.denoise_strength, width=5)
        denoise_value.pack(side='left')
        self.preprocessing_controls.append(denoise_value)
        
        # Size limits section
        size_frame = tk.LabelFrame(content_frame, text="Image Size Limits", padx=15, pady=10)
        size_frame.pack(fill='x', padx=20, pady=(10, 0))
        self.preprocessing_controls.append(size_frame)
        
        # Max dimension
        dimension_frame = tk.Frame(size_frame)
        dimension_frame.pack(fill='x', pady=5)
        dimension_label = tk.Label(dimension_frame, text="Max Dimension:", width=20, anchor='w')
        dimension_label.pack(side='left')
        self.preprocessing_controls.append(dimension_label)
        
        self.max_dimension = tk.IntVar(value=self.settings['preprocessing']['max_image_dimension'])
        self.dimension_spinbox = tb.Spinbox(
            dimension_frame,
            from_=500,
            to=4000,
            textvariable=self.max_dimension,
            increment=100,
            width=10
        )
        self.dimension_spinbox.pack(side='left', padx=10)
        self.preprocessing_controls.append(self.dimension_spinbox)
        
        tk.Label(dimension_frame, text="pixels").pack(side='left')
        
        # Max pixels
        pixels_frame = tk.Frame(size_frame)
        pixels_frame.pack(fill='x', pady=5)
        pixels_label = tk.Label(pixels_frame, text="Max Total Pixels:", width=20, anchor='w')
        pixels_label.pack(side='left')
        self.preprocessing_controls.append(pixels_label)
        
        self.max_pixels = tk.IntVar(value=self.settings['preprocessing']['max_image_pixels'])
        self.pixels_spinbox = tb.Spinbox(
            pixels_frame,
            from_=1000000,
            to=10000000,
            textvariable=self.max_pixels,
            increment=100000,
            width=10
        )
        self.pixels_spinbox.pack(side='left', padx=10)
        self.preprocessing_controls.append(self.pixels_spinbox)
        
        tk.Label(pixels_frame, text="pixels").pack(side='left')
        
        # Compression section
        compression_frame = tk.LabelFrame(content_frame, text="Image Compression (applies to OCR uploads)", padx=15, pady=10)
        compression_frame.pack(fill='x', padx=20, pady=(10, 0))
        # Do NOT add compression controls to preprocessing_controls; keep independent of preprocessing toggle
        
        # Enable compression toggle
        self.compression_enabled_var = tk.BooleanVar(value=self.settings.get('compression', {}).get('enabled', False))
        compression_toggle = tb.Checkbutton(
            compression_frame,
            text="Enable compression for OCR uploads",
            variable=self.compression_enabled_var,
            bootstyle="round-toggle",
        )
        compression_toggle.pack(anchor='w')
        self.compression_toggle = compression_toggle
        
        # Hook toggle to enable/disable compression fields
        def _toggle_compression_enabled():
            enabled = bool(self.compression_enabled_var.get())
            state = 'normal' if enabled else 'disabled'
            try:
                self.compression_format_combo.config(state='readonly' if enabled else 'disabled')
            except Exception:
                pass
            for w in [getattr(self, 'jpeg_quality_spin', None), getattr(self, 'png_level_spin', None), getattr(self, 'webp_quality_spin', None)]:
                try:
                    if w is not None:
                        w.config(state=state)
                except Exception:
                    pass
        compression_toggle.config(command=_toggle_compression_enabled)
        
        # Format selection
        format_row = tk.Frame(compression_frame)
        format_row.pack(fill='x', pady=5)
        tk.Label(format_row, text="Format:", width=20, anchor='w').pack(side='left')
        self.compression_format_var = tk.StringVar(value=self.settings.get('compression', {}).get('format', 'jpeg'))
        self.compression_format_combo = ttk.Combobox(
            format_row,
            textvariable=self.compression_format_var,
            values=['jpeg', 'png', 'webp'],
            state='readonly',
            width=10
        )
        self.compression_format_combo.pack(side='left', padx=10)
        
        # JPEG quality
        self.jpeg_row = tk.Frame(compression_frame)
        self.jpeg_row.pack(fill='x', pady=5)
        tk.Label(self.jpeg_row, text="JPEG Quality:", width=20, anchor='w').pack(side='left')
        self.jpeg_quality_var = tk.IntVar(value=self.settings.get('compression', {}).get('jpeg_quality', 85))
        self.jpeg_quality_spin = tb.Spinbox(
            self.jpeg_row,
            from_=1,
            to=95,
            textvariable=self.jpeg_quality_var,
            width=10
        )
        self.jpeg_quality_spin.pack(side='left', padx=10)
        tk.Label(self.jpeg_row, text="(higher = better quality, larger size)", font=('Arial', 9), fg='gray').pack(side='left')
        
        # PNG compression level
        self.png_row = tk.Frame(compression_frame)
        self.png_row.pack(fill='x', pady=5)
        tk.Label(self.png_row, text="PNG Compression:", width=20, anchor='w').pack(side='left')
        self.png_level_var = tk.IntVar(value=self.settings.get('compression', {}).get('png_compress_level', 6))
        self.png_level_spin = tb.Spinbox(
            self.png_row,
            from_=0,
            to=9,
            textvariable=self.png_level_var,
            width=10
        )
        self.png_level_spin.pack(side='left', padx=10)
        tk.Label(self.png_row, text="(0 = fastest, 9 = smallest)", font=('Arial', 9), fg='gray').pack(side='left')
        
        # WEBP quality
        self.webp_row = tk.Frame(compression_frame)
        self.webp_row.pack(fill='x', pady=5)
        tk.Label(self.webp_row, text="WEBP Quality:", width=20, anchor='w').pack(side='left')
        self.webp_quality_var = tk.IntVar(value=self.settings.get('compression', {}).get('webp_quality', 85))
        self.webp_quality_spin = tb.Spinbox(
            self.webp_row,
            from_=1,
            to=100,
            textvariable=self.webp_quality_var,
            width=10
        )
        self.webp_quality_spin.pack(side='left', padx=10)
        tk.Label(self.webp_row, text="(higher = better quality, larger size)", font=('Arial', 9), fg='gray').pack(side='left')
        
        # Hook to toggle visibility based on format
        self.compression_format_combo.bind('<<ComboboxSelected>>', lambda e: self._toggle_compression_format())
        self._toggle_compression_format()
        # Apply enabled/disabled state for compression fields initially
        try:
            _toggle_compression_enabled()
        except Exception:
            pass
        
        # Chunk settings for large images (moved above compression)
        chunk_frame = tk.LabelFrame(content_frame, text="Large Image Processing", padx=15, pady=10)
        chunk_frame.pack(fill='x', padx=20, pady=(10, 0), before=compression_frame)
        self.preprocessing_controls.append(chunk_frame)
        
        # HD Strategy (Inpainting acceleration)
        hd_frame = tk.LabelFrame(chunk_frame, text="Inpainting HD Strategy", padx=10, pady=8)
        hd_frame.pack(fill='x', pady=(5, 10))
        
        # Strategy selector
        strat_row = tk.Frame(hd_frame)
        strat_row.pack(fill='x', pady=4)
        tk.Label(strat_row, text="Strategy:", width=20, anchor='w').pack(side='left')
        self.hd_strategy_var = tk.StringVar(value=self.settings.get('advanced', {}).get('hd_strategy', 'resize'))
        self.hd_strategy_combo = ttk.Combobox(
            strat_row,
            textvariable=self.hd_strategy_var,
            values=['original', 'resize', 'crop'],
            state='readonly',
            width=12
        )
        self.hd_strategy_combo.pack(side='left', padx=10)
        tk.Label(strat_row, text="(original = legacy full-image; resize/crop = faster)", font=('Arial', 9), fg='gray').pack(side='left')
        
        # Resize limit row
        self.hd_resize_row = tk.Frame(hd_frame)
        self.hd_resize_row.pack(fill='x', pady=4)
        tk.Label(self.hd_resize_row, text="Resize limit (long edge):", width=20, anchor='w').pack(side='left')
        self.hd_resize_limit_var = tk.IntVar(value=int(self.settings.get('advanced', {}).get('hd_strategy_resize_limit', 1536)))
        self.hd_resize_limit_spin = tb.Spinbox(
            self.hd_resize_row,
            from_=512,
            to=4096,
            textvariable=self.hd_resize_limit_var,
            increment=64,
            width=10
        )
        self.hd_resize_limit_spin.pack(side='left', padx=10)
        tk.Label(self.hd_resize_row, text="px").pack(side='left')
        
        # Crop params rows
        self.hd_crop_margin_row = tk.Frame(hd_frame)
        self.hd_crop_margin_row.pack(fill='x', pady=4)
        tk.Label(self.hd_crop_margin_row, text="Crop margin:", width=20, anchor='w').pack(side='left')
        self.hd_crop_margin_var = tk.IntVar(value=int(self.settings.get('advanced', {}).get('hd_strategy_crop_margin', 16)))
        self.hd_crop_margin_spin = tb.Spinbox(
            self.hd_crop_margin_row,
            from_=0,
            to=256,
            textvariable=self.hd_crop_margin_var,
            increment=2,
            width=10
        )
        self.hd_crop_margin_spin.pack(side='left', padx=10)
        tk.Label(self.hd_crop_margin_row, text="px").pack(side='left')
        
        self.hd_crop_trigger_row = tk.Frame(hd_frame)
        self.hd_crop_trigger_row.pack(fill='x', pady=4)
        tk.Label(self.hd_crop_trigger_row, text="Crop trigger size:", width=20, anchor='w').pack(side='left')
        self.hd_crop_trigger_var = tk.IntVar(value=int(self.settings.get('advanced', {}).get('hd_strategy_crop_trigger_size', 1024)))
        self.hd_crop_trigger_spin = tb.Spinbox(
            self.hd_crop_trigger_row,
            from_=256,
            to=4096,
            textvariable=self.hd_crop_trigger_var,
            increment=64,
            width=10
        )
        self.hd_crop_trigger_spin.pack(side='left', padx=10)
        tk.Label(self.hd_crop_trigger_row, text="px (apply crop only if long edge > trigger)").pack(side='left')
        
        # Toggle rows based on current selection
        def _on_hd_strategy_change(*_):
            strat = self.hd_strategy_var.get()
            try:
                if strat == 'resize':
                    self.hd_resize_row.pack(fill='x', pady=4)
                    self.hd_crop_margin_row.pack_forget()
                    self.hd_crop_trigger_row.pack_forget()
                elif strat == 'crop':
                    self.hd_resize_row.pack_forget()
                    self.hd_crop_margin_row.pack(fill='x', pady=4)
                    self.hd_crop_trigger_row.pack(fill='x', pady=4)
                else:  # original
                    self.hd_resize_row.pack_forget()
                    self.hd_crop_margin_row.pack_forget()
                    self.hd_crop_trigger_row.pack_forget()
            except Exception:
                pass
        
        self.hd_strategy_combo.bind('<<ComboboxSelected>>', _on_hd_strategy_change)
        _on_hd_strategy_change()
        
        # Clarifying note about precedence with tiling
        try:
            tk.Label(
                hd_frame,
                text="Note: HD Strategy (resize/crop) takes precedence over Inpainting Tiling when it triggers.\nSet strategy to 'original' if you want tiling to control large-image behavior.",
                font=('Arial', 9),
                fg='gray',
                justify='left'
            ).pack(anchor='w', pady=(2, 2))
        except Exception:
            pass
        
        # Chunk height
        self.chunk_frame = chunk_frame
        chunk_height_frame = tk.Frame(chunk_frame)
        chunk_height_frame.pack(fill='x', pady=5)
        self.chunk_height_label = tk.Label(chunk_height_frame, text="Chunk Height:", width=20, anchor='w')
        self.chunk_height_label.pack(side='left')
        self.preprocessing_controls.append(self.chunk_height_label)
        
        self.chunk_height = tk.IntVar(value=self.settings['preprocessing']['chunk_height'])
        self.chunk_height_spinbox = tb.Spinbox(
            chunk_height_frame,
            from_=500,
            to=2000,
            textvariable=self.chunk_height,
            increment=100,
            width=10
        )
        self.chunk_height_spinbox.pack(side='left', padx=10)
        self.preprocessing_controls.append(self.chunk_height_spinbox)
        
        self.chunk_height_unit_label = tk.Label(chunk_height_frame, text="pixels")
        self.chunk_height_unit_label.pack(side='left')
        self.preprocessing_controls.append(self.chunk_height_unit_label)
        
        # Chunk overlap
        chunk_overlap_frame = tk.Frame(chunk_frame)
        chunk_overlap_frame.pack(fill='x', pady=5)
        self.chunk_overlap_label = tk.Label(chunk_overlap_frame, text="Chunk Overlap:", width=20, anchor='w')
        self.chunk_overlap_label.pack(side='left')
        self.preprocessing_controls.append(self.chunk_overlap_label)
        
        self.chunk_overlap = tk.IntVar(value=self.settings['preprocessing']['chunk_overlap'])
        self.chunk_overlap_spinbox = tb.Spinbox(
            chunk_overlap_frame,
            from_=0,
            to=200,
            textvariable=self.chunk_overlap,
            increment=10,
            width=10
        )
        self.chunk_overlap_spinbox.pack(side='left', padx=10)
        self.preprocessing_controls.append(self.chunk_overlap_spinbox)
        
        self.chunk_overlap_unit_label = tk.Label(chunk_overlap_frame, text="pixels")
        self.chunk_overlap_unit_label.pack(side='left')
        self.preprocessing_controls.append(self.chunk_overlap_unit_label)

        # Inpainting Tiling section (add after the "Large Image Processing" section)
        self.tiling_frame = tk.LabelFrame(content_frame, text="Inpainting Tiling", padx=15, pady=10)
        self.tiling_frame.pack(fill='x', padx=20, pady=(10, 0))
        tiling_frame = self.tiling_frame
        self.preprocessing_controls.append(self.tiling_frame)

        # Enable tiling
        # Prefer values from legacy 'tiling' section if present, otherwise use 'preprocessing'
        tiling_enabled_value = self.settings['preprocessing'].get('inpaint_tiling_enabled', False)
        if 'tiling' in self.settings and isinstance(self.settings['tiling'], dict) and 'enabled' in self.settings['tiling']:
            tiling_enabled_value = self.settings['tiling']['enabled']
        self.inpaint_tiling_enabled = tk.BooleanVar(value=tiling_enabled_value)
        tiling_enable_cb = tb.Checkbutton(
            tiling_frame,
            text="Enable automatic tiling for inpainting (processes large images in tiles)",
            variable=self.inpaint_tiling_enabled,
            command=lambda: self._toggle_tiling_controls(),
            bootstyle="round-toggle"
        )
        tiling_enable_cb.pack(anchor='w', pady=(5, 10))

        # Tile size
        tile_size_frame = tk.Frame(tiling_frame)
        tile_size_frame.pack(fill='x', pady=5)
        tile_size_label = tk.Label(tile_size_frame, text="Tile Size:", width=20, anchor='w')
        tile_size_label.pack(side='left')

        tile_size_value = self.settings['preprocessing'].get('inpaint_tile_size', 512)
        if 'tiling' in self.settings and isinstance(self.settings['tiling'], dict) and 'tile_size' in self.settings['tiling']:
            tile_size_value = self.settings['tiling']['tile_size']
        self.inpaint_tile_size = tk.IntVar(value=tile_size_value)
        self.tile_size_spinbox = tb.Spinbox(
            tile_size_frame,
            from_=256,
            to=2048,
            textvariable=self.inpaint_tile_size,
            increment=128,
            width=10
        )
        self.tile_size_spinbox.pack(side='left', padx=10)

        tk.Label(tile_size_frame, text="pixels").pack(side='left')
        # Initial tiling fields state
        try:
            self._toggle_tiling_controls()
        except Exception:
            pass

        # Tile overlap
        tile_overlap_frame = tk.Frame(tiling_frame)
        tile_overlap_frame.pack(fill='x', pady=5)
        tile_overlap_label = tk.Label(tile_overlap_frame, text="Tile Overlap:", width=20, anchor='w')
        tile_overlap_label.pack(side='left')

        tile_overlap_value = self.settings['preprocessing'].get('inpaint_tile_overlap', 64)
        if 'tiling' in self.settings and isinstance(self.settings['tiling'], dict) and 'tile_overlap' in self.settings['tiling']:
            tile_overlap_value = self.settings['tiling']['tile_overlap']
        self.inpaint_tile_overlap = tk.IntVar(value=tile_overlap_value)
        self.tile_overlap_spinbox = tb.Spinbox(
            tile_overlap_frame,
            from_=0,
            to=256,
            textvariable=self.inpaint_tile_overlap,
            increment=16,
            width=10
        )
        self.tile_overlap_spinbox.pack(side='left', padx=10)

        tk.Label(tile_overlap_frame, text="pixels").pack(side='left')

    def _create_inpainting_tab(self, notebook):
        """Create inpainting settings tab with comprehensive per-text-type dilation controls"""
        frame = ttk.Frame(notebook)
        notebook.add(frame, text="Inpainting")
        
        content_frame = tk.Frame(frame)
        content_frame.pack(fill='both', expand=True, padx=5, pady=5)
        
        # General Mask Settings (applies to all inpainting methods)
        mask_frame = tk.LabelFrame(content_frame, text="Mask Settings", padx=15, pady=10)
        mask_frame.pack(fill='x', padx=20, pady=(20, 10))
        
        # Auto toggle (affects both mask dilation and iterations)
        auto_global_frame = tk.Frame(mask_frame)
        auto_global_frame.pack(fill='x', pady=(0, 5))
        if not hasattr(self, 'auto_iterations_var'):
            self.auto_iterations_var = tk.BooleanVar(value=self.settings.get('auto_iterations', True))
        tb.Checkbutton(
            auto_global_frame,
            text="Auto (affects mask dilation and iterations)",
            variable=self.auto_iterations_var,
            command=self._toggle_iteration_controls,
            bootstyle="round-toggle"
        ).pack(anchor='w')

        # Mask dilation size
        dilation_frame = tk.Frame(mask_frame)
        dilation_frame.pack(fill='x', pady=5)
        
        tk.Label(dilation_frame, text="Mask Dilation:", width=15, anchor='w').pack(side='left')
        self.mask_dilation_var = tk.IntVar(value=self.settings.get('mask_dilation', 15))
        self.mask_dilation_spinbox = tb.Spinbox(
            dilation_frame,
            from_=0,
            to=50,
            textvariable=self.mask_dilation_var,
            increment=5,
            width=10
        )
        self.mask_dilation_spinbox.pack(side='left', padx=10)
        tk.Label(dilation_frame, text="pixels (expand mask beyond text)").pack(side='left')
        
        # Per-Text-Type Iterations - EXPANDED SECTION
        iterations_label_frame = tk.LabelFrame(mask_frame, text="Dilation Iterations Control", padx=10, pady=5)
        iterations_label_frame.pack(fill='x', pady=(10, 5))
        
        # All Iterations Master Control (NEW)
        all_iter_frame = tk.Frame(iterations_label_frame)
        all_iter_frame.pack(fill='x', pady=5)
        
        # Auto-iterations toggle (secondary control reflects the same setting)
        if not hasattr(self, 'auto_iterations_var'):
            self.auto_iterations_var = tk.BooleanVar(value=self.settings.get('auto_iterations', True))
        auto_iter_checkbox = tb.Checkbutton(
            all_iter_frame,
            text="Auto (set by image: B&W vs Color)",
            variable=self.auto_iterations_var,
            command=self._toggle_iteration_controls,
            bootstyle="round-toggle"
        )
        auto_iter_checkbox.pack(side='left', padx=(0, 10))
        
        # Checkbox to enable/disable uniform iterations
        self.use_all_iterations_var = tk.BooleanVar(value=self.settings.get('use_all_iterations', True))
        all_iter_checkbox = tb.Checkbutton(
            all_iter_frame,
            text="Use Same For All:",
            variable=self.use_all_iterations_var,
            command=self._toggle_iteration_controls,
            bootstyle="round-toggle"
        )
        all_iter_checkbox.pack(side='left', padx=(0, 10))
        self.use_all_iterations_checkbox = all_iter_checkbox
        
        self.all_iterations_var = tk.IntVar(value=self.settings.get('all_iterations', 2))
        self.all_iterations_spinbox = tb.Spinbox(
            all_iter_frame,
            from_=0,
            to=5,
            textvariable=self.all_iterations_var,
            width=10,
            state='disabled' if not self.use_all_iterations_var.get() else 'normal'
        )
        self.all_iterations_spinbox.pack(side='left', padx=10)
        tk.Label(all_iter_frame, text="iterations (applies to all text types)").pack(side='left')
        
        # Separator
        ttk.Separator(iterations_label_frame, orient='horizontal').pack(fill='x', pady=(10, 5))
        
        # Individual Controls Label
        tk.Label(
            iterations_label_frame, 
            text="Individual Text Type Controls:",
            font=('Arial', 9, 'bold')
        ).pack(anchor='w', pady=(5, 5))
        
        # Text Bubble iterations (modified from original bubble iterations)
        text_bubble_iter_frame = tk.Frame(iterations_label_frame)
        text_bubble_iter_frame.pack(fill='x', pady=5)
        
        text_bubble_label = tk.Label(text_bubble_iter_frame, text="Text Bubbles:", width=15, anchor='w')
        text_bubble_label.pack(side='left')
        self.text_bubble_iterations_var = tk.IntVar(value=self.settings.get('text_bubble_dilation_iterations', 
                                                                            self.settings.get('bubble_dilation_iterations', 2)))
        self.text_bubble_iter_spinbox = tb.Spinbox(
            text_bubble_iter_frame,
            from_=0,
            to=5,
            textvariable=self.text_bubble_iterations_var,
            width=10
        )
        self.text_bubble_iter_spinbox.pack(side='left', padx=10)
        tk.Label(text_bubble_iter_frame, text="iterations (speech/dialogue bubbles)").pack(side='left')
        
        # Empty Bubble iterations (NEW)
        empty_bubble_iter_frame = tk.Frame(iterations_label_frame)
        empty_bubble_iter_frame.pack(fill='x', pady=5)
        
        empty_bubble_label = tk.Label(empty_bubble_iter_frame, text="Empty Bubbles:", width=15, anchor='w')
        empty_bubble_label.pack(side='left')
        self.empty_bubble_iterations_var = tk.IntVar(value=self.settings.get('empty_bubble_dilation_iterations', 3))
        self.empty_bubble_iter_spinbox = tb.Spinbox(
            empty_bubble_iter_frame,
            from_=0,
            to=5,
            textvariable=self.empty_bubble_iterations_var,
            width=10
        )
        self.empty_bubble_iter_spinbox.pack(side='left', padx=10)
        tk.Label(empty_bubble_iter_frame, text="iterations (empty speech bubbles)").pack(side='left')
        
        # Free text iterations
        free_text_iter_frame = tk.Frame(iterations_label_frame)
        free_text_iter_frame.pack(fill='x', pady=5)
        
        free_text_label = tk.Label(free_text_iter_frame, text="Free Text:", width=15, anchor='w')
        free_text_label.pack(side='left')
        self.free_text_iterations_var = tk.IntVar(value=self.settings.get('free_text_dilation_iterations', 0))
        self.free_text_iter_spinbox = tb.Spinbox(
            free_text_iter_frame,
            from_=0,
            to=5,
            textvariable=self.free_text_iterations_var,
            width=10
        )
        self.free_text_iter_spinbox.pack(side='left', padx=10)
        tk.Label(free_text_iter_frame, text="iterations (0 = perfect for B&W panels)").pack(side='left')
        
        # Store individual control widgets for enable/disable
        self.individual_iteration_controls = [
            (text_bubble_label, self.text_bubble_iter_spinbox),
            (empty_bubble_label, self.empty_bubble_iter_spinbox),
            (free_text_label, self.free_text_iter_spinbox)
        ]
        
        # Apply initial state
        self._toggle_iteration_controls()
        
        # Legacy iterations (backwards compatibility)
        self.bubble_iterations_var = self.text_bubble_iterations_var  # Link to text bubble for legacy
        self.dilation_iterations_var = self.text_bubble_iterations_var  # Legacy support
        
        # Quick presets - UPDATED VERSION
        preset_frame = tk.Frame(mask_frame)
        preset_frame.pack(fill='x', pady=(10, 5))
        
        tk.Label(preset_frame, text="Quick Presets:").pack(side='left', padx=(0, 10))
        
        tb.Button(
            preset_frame,
            text="B&W Manga",
            command=lambda: self._set_mask_preset(15, False, 2, 2, 3, 0),
            bootstyle="secondary",
            width=12
        ).pack(side='left', padx=2)
        
        tb.Button(
            preset_frame,
            text="Colored",
            command=lambda: self._set_mask_preset(15, False, 2, 2, 3, 3),
            bootstyle="secondary",
            width=12
        ).pack(side='left', padx=2)
        
        tb.Button(
            preset_frame,
            text="Uniform",
            command=lambda: self._set_mask_preset(0, True, 2, 2, 2, 0),
            bootstyle="secondary",
            width=12
        ).pack(side='left', padx=2)
        
        # Help text - UPDATED
        tk.Label(
            mask_frame,
            text="💡 B&W Manga: Optimized for black & white panels with clean bubbles\n"
                 "💡 Colored: For colored manga with complex backgrounds\n"
                 "💡 Aggressive: For difficult text removal cases\n"
                 "💡 Uniform: Good for Manga-OCR\n"
                 "ℹ️ Empty bubbles often need more iterations than text bubbles\n"
                 "ℹ️ Set Free Text to 0 for crisp B&W panels without bleeding",
            font=('Arial', 9),
            fg='gray',
            justify='left'
        ).pack(anchor='w', pady=(10, 0))
        
        # Note about method selection
        info_frame = tk.Frame(content_frame)
        info_frame.pack(fill='x', padx=20, pady=(20, 0))
        
        tk.Label(
            info_frame,
            text="ℹ️ Note: Inpainting method (Cloud/Local) and model selection are configured\n"
                 "     in the Manga tab when you select images for translation.",
            font=('Arial', 10),
            fg='#4a9eff',
            justify='left'
        ).pack(anchor='w')

    def _toggle_iteration_controls(self):
        """Enable/disable iteration controls based on Auto and 'Use Same For All' toggles"""
        auto_on = getattr(self, 'auto_iterations_var', tk.BooleanVar(value=True)).get()
        use_all = self.use_all_iterations_var.get()
        
        if auto_on:
            # Disable everything when auto is on
            try:
                self.all_iterations_spinbox.config(state='disabled')
            except Exception:
                pass
            try:
                if hasattr(self, 'use_all_iterations_checkbox'):
                    self.use_all_iterations_checkbox.config(state='disabled')
            except Exception:
                pass
            try:
                if hasattr(self, 'mask_dilation_spinbox'):
                    self.mask_dilation_spinbox.config(state='disabled')
            except Exception:
                pass
            for label, spinbox in getattr(self, 'individual_iteration_controls', []):
                try:
                    spinbox.config(state='disabled')
                    label.config(fg='gray')
                except Exception:
                    pass
            return
        
        # Auto off -> respect 'use all'
        try:
            self.all_iterations_spinbox.config(state='normal' if use_all else 'disabled')
        except Exception:
            pass
        try:
            if hasattr(self, 'use_all_iterations_checkbox'):
                self.use_all_iterations_checkbox.config(state='normal')
        except Exception:
            pass
        try:
            if hasattr(self, 'mask_dilation_spinbox'):
                self.mask_dilation_spinbox.config(state='normal')
        except Exception:
            pass
        for label, spinbox in getattr(self, 'individual_iteration_controls', []):
            state = 'disabled' if use_all else 'normal'
            try:
                spinbox.config(state=state)
                label.config(fg='gray' if use_all else 'white')
            except Exception:
                pass

    def _set_mask_preset(self, dilation, use_all, all_iter, text_bubble_iter, empty_bubble_iter, free_text_iter):
        """Set mask dilation preset values with comprehensive iteration controls"""
        self.mask_dilation_var.set(dilation)
        self.use_all_iterations_var.set(use_all)
        self.all_iterations_var.set(all_iter)
        self.text_bubble_iterations_var.set(text_bubble_iter)
        self.empty_bubble_iterations_var.set(empty_bubble_iter)
        self.free_text_iterations_var.set(free_text_iter)
        self._toggle_iteration_controls()
    
    def _create_cloud_api_tab(self, parent):
            """Create cloud API settings tab"""
            # NO CANVAS - JUST USE PARENT DIRECTLY
            frame = parent
            
            # API Model Selection
            model_frame = tk.LabelFrame(frame, text="Inpainting Model", padx=15, pady=10)
            model_frame.pack(fill='x', padx=20, pady=(20, 0))
            
            tk.Label(model_frame, text="Select the Replicate model to use for inpainting:").pack(anchor='w', pady=(0, 10))
            
            # Model options
            self.cloud_model_var = tk.StringVar(value=self.settings.get('cloud_inpaint_model', 'ideogram-v2'))
            
            models = [
                ('ideogram-v2', 'Ideogram V2 (Best quality, with prompts)', 'ideogram-ai/ideogram-v2'),
                ('sd-inpainting', 'Stable Diffusion Inpainting (Classic, fast)', 'stability-ai/stable-diffusion-inpainting'),
                ('flux-inpainting', 'FLUX Dev Inpainting (High quality)', 'zsxkib/flux-dev-inpainting'),
                ('custom', 'Custom Model (Enter model identifier)', '')
            ]
            
            for value, text, model_id in models:
                row_frame = tk.Frame(model_frame)
                row_frame.pack(fill='x', pady=2)
                
                rb = tb.Radiobutton(
                    row_frame,
                    text=text,
                    variable=self.cloud_model_var,
                    value=value,
                    command=self._on_cloud_model_change
                )
                rb.pack(side='left')
                
                if model_id:
                    tk.Label(row_frame, text=f"({model_id})", font=('Arial', 8), fg='gray').pack(side='left', padx=(10, 0))
            
            # Custom version ID (now model identifier)
            self.custom_version_frame = tk.Frame(model_frame)
            self.custom_version_frame.pack(fill='x', pady=(10, 0))
            
            tk.Label(self.custom_version_frame, text="Model ID:", width=15, anchor='w').pack(side='left')
            self.custom_version_var = tk.StringVar(value=self.settings.get('cloud_custom_version', ''))
            self.custom_version_entry = tk.Entry(self.custom_version_frame, textvariable=self.custom_version_var, width=50)
            self.custom_version_entry.pack(side='left', padx=10)
            
            # Add helper text for custom model
            helper_text = tk.Label(
                self.custom_version_frame, 
                text="Format: owner/model-name (e.g. stability-ai/stable-diffusion-inpainting)",
                font=('Arial', 8), 
                fg='gray'
            )
            helper_text.pack(anchor='w', padx=(70, 0), pady=(2, 0))
            
            # Initially hide custom version entry
            if self.cloud_model_var.get() != 'custom':
                self.custom_version_frame.pack_forget()
            
            # Performance Settings
            perf_frame = tk.LabelFrame(frame, text="Performance Settings", padx=15, pady=10)
            perf_frame.pack(fill='x', padx=20, pady=(20, 0))
    
            # Timeout
            timeout_frame = tk.Frame(perf_frame)
            timeout_frame.pack(fill='x', pady=5)
            
            tk.Label(timeout_frame, text="API Timeout:", width=15, anchor='w').pack(side='left')
            self.cloud_timeout_var = tk.IntVar(value=self.settings.get('cloud_timeout', 60))
            timeout_spinbox = tb.Spinbox(
                timeout_frame,
                from_=30,
                to=300,
                textvariable=self.cloud_timeout_var,
                width=10
            )
            timeout_spinbox.pack(side='left', padx=10)
            tk.Label(timeout_frame, text="seconds", font=('Arial', 9)).pack(side='left')
            
            # Help text
            help_frame = tk.Frame(frame)
            help_frame.pack(fill='x', padx=20, pady=20)
            
            help_text = tk.Label(
                help_frame,
                text="💡 Tips:\n"
                     "• Ideogram V2 is currently the best quality option\n"
                     "• SD inpainting is fast and supports prompts\n"
                     "• FLUX inpainting offers high quality results\n"
                     "• Find more models at replicate.com/collections/inpainting",
                font=('Arial', 9),
                fg='gray',
                justify='left'
            )
            help_text.pack(anchor='w')
            
            # Prompt Settings (for all models except custom)
            self.prompt_frame = tk.LabelFrame(frame, text="Prompt Settings", padx=15, pady=10)
            self.prompt_frame.pack(fill='x', padx=20, pady=(0, 20))
            
            # Positive prompt
            tk.Label(self.prompt_frame, text="Inpainting Prompt:").pack(anchor='w', pady=(0, 5))
            self.cloud_prompt_var = tk.StringVar(value=self.settings.get('cloud_inpaint_prompt', 'clean background, smooth surface'))
            prompt_entry = tk.Entry(self.prompt_frame, textvariable=self.cloud_prompt_var, width=60)
            prompt_entry.pack(fill='x', padx=(20, 20))
            
            # Add note about prompts
            tk.Label(
                self.prompt_frame, 
                text="Tip: Describe what you want in the inpainted area (e.g., 'white wall', 'wooden floor')",
                font=('Arial', 8), 
                fg='gray'
            ).pack(anchor='w', padx=(20, 0), pady=(2, 10))
            
            # Negative prompt (mainly for SD)
            self.negative_prompt_label = tk.Label(self.prompt_frame, text="Negative Prompt (SD only):")
            self.negative_prompt_label.pack(anchor='w', pady=(0, 5))
            self.cloud_negative_prompt_var = tk.StringVar(value=self.settings.get('cloud_negative_prompt', 'text, writing, letters'))
            self.negative_entry = tk.Entry(self.prompt_frame, textvariable=self.cloud_negative_prompt_var, width=60)
            self.negative_entry.pack(fill='x', padx=(20, 20))
            
            # Inference steps (for SD)
            self.steps_frame = tk.Frame(self.prompt_frame)
            self.steps_frame.pack(fill='x', pady=(10, 5))
            
            self.steps_label = tk.Label(self.steps_frame, text="Inference Steps (SD only):", width=20, anchor='w')
            self.steps_label.pack(side='left', padx=(20, 0))
            self.cloud_steps_var = tk.IntVar(value=self.settings.get('cloud_inference_steps', 20))
            self.steps_spinbox = tb.Spinbox(
                self.steps_frame,
                from_=10,
                to=50,
                textvariable=self.cloud_steps_var,
                width=10
            )
            self.steps_spinbox.pack(side='left', padx=10)
            tk.Label(self.steps_frame, text="(Higher = better quality, slower)", font=('Arial', 9), fg='gray').pack(side='left')
            
            # Initially hide prompt frame if not using appropriate model
            if self.cloud_model_var.get() == 'custom':
                self.prompt_frame.pack_forget()
            
            # Show/hide SD-specific options based on model
            self._on_cloud_model_change()
    
    def _on_cloud_model_change(self):
        """Handle cloud model selection change"""
        model = self.cloud_model_var.get()
        
        # Show/hide custom version entry
        if model == 'custom':
            self.custom_version_frame.pack(fill='x', pady=(10, 0))
            # DON'T HIDE THE PROMPT FRAME FOR CUSTOM MODELS
            self.prompt_frame.pack(fill='x', padx=20, pady=(20, 0))
        else:
            self.custom_version_frame.pack_forget()
            self.prompt_frame.pack(fill='x', padx=20, pady=(20, 0))
        
        # Show/hide SD-specific options
        if model == 'sd-inpainting':
            # Show negative prompt and steps
            self.negative_prompt_label.pack(anchor='w', pady=(10, 5))
            self.negative_entry.pack(fill='x', padx=(20, 0))
            self.steps_frame.pack(fill='x', pady=(10, 0))
        else:
            # Hide SD-specific options
            self.negative_prompt_label.pack_forget()
            self.negative_entry.pack_forget()
            self.steps_frame.pack_forget()
        
    def _toggle_preprocessing(self):
        """Enable/disable preprocessing controls based on main toggle"""
        enabled = self.preprocess_enabled.get()
        
        # Widgets that must remain enabled regardless of toggle (widgets only, not Tk variables)
        always_on = []
        for name in [
            'tiling_frame',
            'tile_size_spinbox', 'tile_overlap_spinbox',
            'chunk_frame', 'chunk_height_spinbox', 'chunk_overlap_spinbox',
            'chunk_height_label', 'chunk_overlap_label',
            'chunk_height_unit_label', 'chunk_overlap_unit_label',
            # Compression controls should always be active (separate from preprocessing)
            'compression_frame', 'compression_toggle', 'compression_format_combo', 'jpeg_quality_spin', 'png_level_spin', 'webp_quality_spin'
        ]:
            if hasattr(self, name):
                always_on.append(getattr(self, name))
        
        for control in self.preprocessing_controls:
            try:
                if control in always_on:
                    # Ensure enabled
                    if isinstance(control, (tk.Scale, tb.Spinbox, tb.Checkbutton)):
                        control.config(state='normal')
                    elif isinstance(control, tk.LabelFrame):
                        control.config(fg='white')
                        self._toggle_frame_children(control, True)
                    elif isinstance(control, tk.Label):
                        control.config(fg='white')
                    elif isinstance(control, tk.Frame):
                        self._toggle_frame_children(control, True)
                    continue
            except Exception:
                pass
            
            # Normal enable/disable logic for other controls
            if isinstance(control, (tk.Scale, tb.Spinbox, tb.Checkbutton)):
                control.config(state='normal' if enabled else 'disabled')
            elif isinstance(control, tk.LabelFrame):
                control.config(fg='white' if enabled else 'gray')
            elif isinstance(control, tk.Label):
                control.config(fg='white' if enabled else 'gray')
            elif isinstance(control, tk.Frame):
                self._toggle_frame_children(control, enabled)
        
        # Final enforcement for always-on widgets (in case they were not in list)
        try:
            if hasattr(self, 'chunk_height_spinbox'):
                self.chunk_height_spinbox.config(state='normal')
            if hasattr(self, 'chunk_overlap_spinbox'):
                self.chunk_overlap_spinbox.config(state='normal')
            if hasattr(self, 'chunk_height_label'):
                self.chunk_height_label.config(fg='white')
            if hasattr(self, 'chunk_overlap_label'):
                self.chunk_overlap_label.config(fg='white')
            if hasattr(self, 'chunk_height_unit_label'):
                self.chunk_height_unit_label.config(fg='white')
            if hasattr(self, 'chunk_overlap_unit_label'):
                self.chunk_overlap_unit_label.config(fg='white')
        except Exception:
            pass
        # Ensure tiling fields respect their own toggle regardless of preprocessing state
        try:
            if hasattr(self, '_toggle_tiling_controls'):
                self._toggle_tiling_controls()
        except Exception:
            pass
    def _toggle_frame_children(self, frame, enabled):
        """Recursively enable/disable all children of a frame"""
        for child in frame.winfo_children():
            if isinstance(child, (tk.Scale, tb.Spinbox, tb.Checkbutton, ttk.Combobox)):
                try:
                    child.config(state='readonly' if (enabled and isinstance(child, ttk.Combobox)) else ('normal' if enabled else 'disabled'))
                except Exception:
                    child.config(state='normal' if enabled else 'disabled')
            elif isinstance(child, tk.Label):
                child.config(fg='white' if enabled else 'gray')
            elif isinstance(child, tk.Frame):
                self._toggle_frame_children(child, enabled)

    def _toggle_roi_locality_controls(self):
        """Show/hide ROI locality controls based on toggle."""
        try:
            enabled = self.roi_locality_var.get()
        except Exception:
            enabled = False
        # Rows to manage
        rows = [
            getattr(self, 'roi_pad_row', None),
            getattr(self, 'roi_min_row', None),
            getattr(self, 'roi_area_row', None),
            getattr(self, 'roi_max_row', None)
        ]
        for row in rows:
            try:
                if row is None: continue
                if enabled:
                    # Only pack if not already managed
                    row.pack(fill='x', pady=5)
                else:
                    row.pack_forget()
            except Exception:
                pass

    def _toggle_tiling_controls(self):
        """Enable/disable tiling size/overlap fields based on tiling toggle."""
        try:
            enabled = bool(self.inpaint_tiling_enabled.get())
        except Exception:
            enabled = False
        state = 'normal' if enabled else 'disabled'
        try:
            self.tile_size_spinbox.config(state=state)
        except Exception:
            pass
        try:
            self.tile_overlap_spinbox.config(state=state)
        except Exception:
            pass

    def _toggle_compression_format(self):
        """Show only the controls relevant to the selected format (hide others)."""
        fmt = getattr(self, 'compression_format_var', tk.StringVar(value='jpeg')).get()
        try:
            # Hide all rows first
            for row in [getattr(self, 'jpeg_row', None), getattr(self, 'png_row', None), getattr(self, 'webp_row', None)]:
                try:
                    if row is not None:
                        row.pack_forget()
                except Exception:
                    pass
            # Show the selected one
            if fmt == 'jpeg':
                if hasattr(self, 'jpeg_row') and self.jpeg_row is not None:
                    self.jpeg_row.pack(fill='x', pady=5)
            elif fmt == 'png':
                if hasattr(self, 'png_row') and self.png_row is not None:
                    self.png_row.pack(fill='x', pady=5)
            else:  # webp
                if hasattr(self, 'webp_row') and self.webp_row is not None:
                    self.webp_row.pack(fill='x', pady=5)
        except Exception:
            pass
    
    def _toggle_ocr_batching_controls(self):
        """Show/hide OCR batching rows based on enable toggle."""
        try:
            enabled = bool(self.ocr_batch_enabled_var.get())
        except Exception:
            enabled = False
        try:
            if hasattr(self, 'ocr_bs_row') and self.ocr_bs_row:
                (self.ocr_bs_row.pack if enabled else self.ocr_bs_row.pack_forget)()
        except Exception:
            pass
        try:
            if hasattr(self, 'ocr_cc_row') and self.ocr_cc_row:
                (self.ocr_cc_row.pack if enabled else self.ocr_cc_row.pack_forget)()
        except Exception:
            pass

    def _create_ocr_tab(self, notebook):
        """Create OCR settings tab with all options"""
        frame = ttk.Frame(notebook)
        notebook.add(frame, text="OCR Settings")
        
        # Main content
        content_frame = tk.Frame(frame)
        content_frame.pack(fill='both', expand=True, padx=5, pady=5)
        
        # Language hints
        lang_frame = tk.LabelFrame(content_frame, text="Language Detection", padx=15, pady=10)
        lang_frame.pack(fill='x', padx=20, pady=20)
        
        tk.Label(
            lang_frame,
            text="Select languages to prioritize during OCR:",
            font=('Arial', 10)
        ).pack(anchor='w', pady=(0, 10))
        
        # Language checkboxes
        self.lang_vars = {}
        languages = [
            ('ja', 'Japanese'),
            ('ko', 'Korean'),
            ('zh', 'Chinese (Simplified)'),
            ('zh-TW', 'Chinese (Traditional)'),
            ('en', 'English')
        ]
        
        lang_grid = tk.Frame(lang_frame)
        lang_grid.pack(fill='x')
        
        for i, (code, name) in enumerate(languages):
            var = tk.BooleanVar(value=code in self.settings['ocr']['language_hints'])
            self.lang_vars[code] = var
            tb.Checkbutton(
                lang_grid,
                text=name,
                variable=var,
                bootstyle="round-toggle"
            ).grid(row=i//2, column=i%2, sticky='w', padx=10, pady=5)
        
        # OCR parameters
        ocr_frame = tk.LabelFrame(content_frame, text="OCR Parameters", padx=15, pady=10)
        ocr_frame.pack(fill='x', padx=20)
        
        # Confidence threshold
        conf_frame = tk.Frame(ocr_frame)
        conf_frame.pack(fill='x', pady=5)
        tk.Label(conf_frame, text="Confidence Threshold:", width=20, anchor='w').pack(side='left')
        self.confidence_threshold = tk.DoubleVar(value=self.settings['ocr']['confidence_threshold'])
        conf_scale = tk.Scale(
            conf_frame,
            from_=0.0, to=1.0,
            resolution=0.01,
            orient='horizontal',
            variable=self.confidence_threshold,
            length=250
        )
        conf_scale.pack(side='left', padx=10)
        tk.Label(conf_frame, textvariable=self.confidence_threshold, width=5).pack(side='left')
        
        # Detection mode
        mode_frame = tk.Frame(ocr_frame)
        mode_frame.pack(fill='x', pady=5)
        tk.Label(mode_frame, text="Detection Mode:", width=20, anchor='w').pack(side='left')
        self.detection_mode = tk.StringVar(value=self.settings['ocr']['text_detection_mode'])
        mode_combo = ttk.Combobox(
            mode_frame,
            textvariable=self.detection_mode,
            values=['document', 'text'],
            state='readonly',
            width=15
        )
        mode_combo.pack(side='left', padx=10)
        
        tk.Label(
            mode_frame, 
            text="(document = better for manga, text = simple layouts)",
            font=('Arial', 9),
            fg='gray'
        ).pack(side='left', padx=5)
        
        # Text merging settings
        merge_frame = tk.LabelFrame(content_frame, text="Text Region Merging", padx=15, pady=10)
        merge_frame.pack(fill='x', padx=20, pady=(10, 0))

        
        # Merge nearby threshold
        nearby_frame = tk.Frame(merge_frame)
        nearby_frame.pack(fill='x', pady=5)
        tk.Label(nearby_frame, text="Merge Distance:", width=20, anchor='w').pack(side='left')
        self.merge_nearby_threshold = tk.IntVar(value=self.settings['ocr']['merge_nearby_threshold'])
        nearby_spinbox = tb.Spinbox(
            nearby_frame,
            from_=0,
            to=200,
            textvariable=self.merge_nearby_threshold,
            increment=10,
            width=10
        )
        nearby_spinbox.pack(side='left', padx=10)
        tk.Label(nearby_frame, text="pixels").pack(side='left')

        # Text Filtering Setting
        filter_frame = tk.LabelFrame(content_frame, text="Text Filtering", padx=15, pady=10)
        filter_frame.pack(fill='x', padx=20, pady=(10, 0))
        
        # Minimum text length
        min_length_frame = tk.Frame(filter_frame)
        min_length_frame.pack(fill='x', pady=5)
        
        tk.Label(min_length_frame, text="Min Text Length:", width=20, anchor='w').pack(side='left')
        self.min_text_length_var = tk.IntVar(
            value=self.settings['ocr'].get('min_text_length', 0)
        )
        min_length_spinbox = tb.Spinbox(
            min_length_frame,
            from_=1,
            to=10,
            textvariable=self.min_text_length_var,
            increment=1,
            width=10
        )
        min_length_spinbox.pack(side='left', padx=10)
        tk.Label(min_length_frame, text="characters").pack(side='left')
        
        tk.Label(
            min_length_frame,
            text="(skip text shorter than this)",
            font=('Arial', 9),
            fg='gray'
        ).pack(side='left', padx=10)
        
        # Exclude English text checkbox
        exclude_english_frame = tk.Frame(filter_frame)
        exclude_english_frame.pack(fill='x', pady=(5, 0))
        
        self.exclude_english_var = tk.BooleanVar(
            value=self.settings['ocr'].get('exclude_english_text', False)
        )
        
        tb.Checkbutton(
            exclude_english_frame,
            text="Exclude primarily English text (tunable threshold)",
            variable=self.exclude_english_var,
            bootstyle="round-toggle"
        ).pack(anchor='w')
        
        # Threshold slider
        english_threshold_frame = tk.Frame(filter_frame)
        english_threshold_frame.pack(fill='x', pady=5)
        tk.Label(english_threshold_frame, text="English Exclude Threshold:", width=28, anchor='w').pack(side='left')
        self.english_exclude_threshold = tk.DoubleVar(
            value=self.settings['ocr'].get('english_exclude_threshold', 0.7)
        )
        threshold_scale = tk.Scale(
            english_threshold_frame,
            from_=0.6, to=0.99,
            resolution=0.01,
            orient='horizontal',
            variable=self.english_exclude_threshold,
            length=250,
            command=lambda v: self.english_threshold_label.config(text=f"{float(v)*100:.0f}%")
        )
        threshold_scale.pack(side='left', padx=10)
        self.english_threshold_label = tk.Label(english_threshold_frame, text=f"{int(self.english_exclude_threshold.get()*100)}%", width=5)
        self.english_threshold_label.pack(side='left')
        
        # Minimum character count
        min_chars_frame = tk.Frame(filter_frame)
        min_chars_frame.pack(fill='x', pady=5)
        tk.Label(min_chars_frame, text="Min chars to exclude as English:", width=28, anchor='w').pack(side='left')
        self.english_exclude_min_chars = tk.IntVar(
            value=self.settings['ocr'].get('english_exclude_min_chars', 4)
        )
        min_chars_spinbox = tb.Spinbox(
            min_chars_frame,
            from_=1,
            to=10,
            textvariable=self.english_exclude_min_chars,
            increment=1,
            width=10
        )
        min_chars_spinbox.pack(side='left', padx=10)
        tk.Label(min_chars_frame, text="characters").pack(side='left')
        
        # Legacy aggressive short-token filter
        exclude_short_frame = tk.Frame(filter_frame)
        exclude_short_frame.pack(fill='x', pady=(5, 0))
        self.english_exclude_short_tokens = tk.BooleanVar(
            value=self.settings['ocr'].get('english_exclude_short_tokens', False)
        )
        tb.Checkbutton(
            exclude_short_frame,
            text="Aggressively drop very short ASCII tokens (legacy)",
            variable=self.english_exclude_short_tokens,
            bootstyle="round-toggle"
        ).pack(anchor='w')
        
        # Help text
        tk.Label(
            filter_frame,
            text="💡 Text filtering helps skip:\n"
                 "   • UI elements and watermarks\n"
                 "   • Page numbers and copyright text\n"
                 "   • Single characters or symbols\n"
                 "   • Non-target language text",
            font=('Arial', 9),
            fg='gray',
            justify='left'
        ).pack(anchor='w', pady=(10, 0))
        
        # Azure-specific OCR settings (existing code continues here)
        azure_ocr_frame = tk.LabelFrame(content_frame, text="Azure OCR Settings", padx=15, pady=10)

        # Azure-specific OCR settings
        azure_ocr_frame = tk.LabelFrame(content_frame, text="Azure OCR Settings", padx=15, pady=10)
        azure_ocr_frame.pack(fill='x', padx=20, pady=(10, 0))

        # Azure merge multiplier
        merge_mult_frame = tk.Frame(azure_ocr_frame)
        merge_mult_frame.pack(fill='x', pady=5)
        tk.Label(merge_mult_frame, text="Merge Multiplier:", width=20, anchor='w').pack(side='left')

        self.azure_merge_multiplier = tk.DoubleVar(
            value=self.settings['ocr'].get('azure_merge_multiplier', 2.0)
        )
        azure_scale = tk.Scale(
            merge_mult_frame,
            from_=1.0,
            to=5.0,
            resolution=0.01,
            orient='horizontal',
            variable=self.azure_merge_multiplier,
            length=200,
            command=lambda v: self._update_azure_label()
        )
        azure_scale.pack(side='left', padx=10)

        self.azure_label = tk.Label(merge_mult_frame, text="2.0x", width=5)
        self.azure_label.pack(side='left')
        self._update_azure_label()

        tk.Label(
            merge_mult_frame,
            text="(multiplies merge distance for Azure lines)",
            font=('Arial', 9),
            fg='gray'
        ).pack(side='left', padx=5)

        # Reading order
        reading_order_frame = tk.Frame(azure_ocr_frame)
        reading_order_frame.pack(fill='x', pady=5)
        tk.Label(reading_order_frame, text="Reading Order:", width=20, anchor='w').pack(side='left')

        self.azure_reading_order = tk.StringVar(
            value=self.settings['ocr'].get('azure_reading_order', 'natural')
        )
        order_combo = ttk.Combobox(
            reading_order_frame,
            textvariable=self.azure_reading_order,
            values=['basic', 'natural'],
            state='readonly',
            width=15
        )
        order_combo.pack(side='left', padx=10)

        tk.Label(
            reading_order_frame,
            text="(natural = better for complex layouts)",
            font=('Arial', 9),
            fg='gray'
        ).pack(side='left', padx=5)

        # Model version
        model_version_frame = tk.Frame(azure_ocr_frame)
        model_version_frame.pack(fill='x', pady=5)
        tk.Label(model_version_frame, text="Model Version:", width=20, anchor='w').pack(side='left')

        self.azure_model_version = tk.StringVar(
            value=self.settings['ocr'].get('azure_model_version', 'latest')
        )
        version_combo = ttk.Combobox(
            model_version_frame,
            textvariable=self.azure_model_version,
            values=['latest', '2022-04-30', '2022-01-30', '2021-09-30'],
            width=15
        )
        version_combo.pack(side='left', padx=10)

        tk.Label(
            model_version_frame,
            text="(use 'latest' for newest features)",
            font=('Arial', 9),
            fg='gray'
        ).pack(side='left', padx=5)

        # Timeout settings
        timeout_frame = tk.Frame(azure_ocr_frame)
        timeout_frame.pack(fill='x', pady=5)

        tk.Label(timeout_frame, text="Max Wait Time:", width=20, anchor='w').pack(side='left')

        self.azure_max_wait = tk.IntVar(
            value=self.settings['ocr'].get('azure_max_wait', 60)
        )
        wait_spinbox = tb.Spinbox(
            timeout_frame,
            from_=10,
            to=120,
            textvariable=self.azure_max_wait,
            increment=5,
            width=10
        )
        wait_spinbox.pack(side='left', padx=10)
        tk.Label(timeout_frame, text="seconds").pack(side='left')

        # Poll interval
        poll_frame = tk.Frame(azure_ocr_frame)
        poll_frame.pack(fill='x', pady=5)

        tk.Label(poll_frame, text="Poll Interval:", width=20, anchor='w').pack(side='left')

        self.azure_poll_interval = tk.DoubleVar(
            value=self.settings['ocr'].get('azure_poll_interval', 0.5)
        )
        poll_scale = tk.Scale(
            poll_frame,
            from_=0.0,
            to=2.0,
            resolution=0.01,
            orient='horizontal',
            variable=self.azure_poll_interval,
            length=200
        )
        poll_scale.pack(side='left', padx=10)

        tk.Label(poll_frame, textvariable=self.azure_poll_interval, width=5).pack(side='left')
        tk.Label(poll_frame, text="sec").pack(side='left')

        # Help text
        tk.Label(
            azure_ocr_frame,
            text="💡 Azure Read API auto-detects language well\n"
                 "💡 Natural reading order works better for manga panels",
            font=('Arial', 9),
            fg='gray',
            justify='left'
        ).pack(anchor='w', pady=(10, 0))
        
        # Rotation correction
        rotation_frame = tk.Frame(merge_frame)
        rotation_frame.pack(fill='x', pady=5)
        self.enable_rotation = tk.BooleanVar(value=self.settings['ocr']['enable_rotation_correction'])
        tb.Checkbutton(
            rotation_frame,
            text="Enable automatic rotation correction for tilted text",
            variable=self.enable_rotation,
            bootstyle="round-toggle"
        ).pack(anchor='w')

        # OCR batching and locality settings
        ocr_batch_frame = tk.LabelFrame(content_frame, text="OCR Batching & Concurrency", padx=15, pady=10)
        ocr_batch_frame.pack(fill='x', padx=20, pady=(10, 0))

        # Enable OCR batching
        self.ocr_batch_enabled_var = tk.BooleanVar(value=self.settings['ocr'].get('ocr_batch_enabled', True))
        tb.Checkbutton(
            ocr_batch_frame,
            text="Enable OCR batching (independent of translation batching)",
            variable=self.ocr_batch_enabled_var,
            command=lambda: self._toggle_ocr_batching_controls(),
            bootstyle="round-toggle"
        ).pack(anchor='w')
        
        # OCR batch size
        ocr_bs_row = tk.Frame(ocr_batch_frame)
        self.ocr_bs_row = ocr_bs_row
        ocr_bs_row.pack(fill='x', pady=5)
        tk.Label(ocr_bs_row, text="OCR Batch Size:", width=20, anchor='w').pack(side='left')
        self.ocr_batch_size_var = tk.IntVar(value=int(self.settings['ocr'].get('ocr_batch_size', 8)))
        self.ocr_batch_size_spin = tb.Spinbox(
            ocr_bs_row,
            from_=1,
            to=32,
            textvariable=self.ocr_batch_size_var,
            width=10
        )
        self.ocr_batch_size_spin.pack(side='left', padx=10)
        tk.Label(ocr_bs_row, text="(Google: items/request; Azure: drives concurrency)", font=('Arial', 9), fg='gray').pack(side='left')

        # OCR Max Concurrency
        ocr_cc_row = tk.Frame(ocr_batch_frame)
        self.ocr_cc_row = ocr_cc_row
        ocr_cc_row.pack(fill='x', pady=5)
        tk.Label(ocr_cc_row, text="OCR Max Concurrency:", width=20, anchor='w').pack(side='left')
        self.ocr_max_conc_var = tk.IntVar(value=int(self.settings['ocr'].get('ocr_max_concurrency', 2)))
        self.ocr_max_conc_spin = tb.Spinbox(
            ocr_cc_row,
            from_=1,
            to=8,
            textvariable=self.ocr_max_conc_var,
            width=10
        )
        self.ocr_max_conc_spin.pack(side='left', padx=10)
        tk.Label(ocr_cc_row, text="(Google: concurrent requests; Azure: workers, capped at 4)", font=('Arial', 9), fg='gray').pack(side='left')
        
        # Apply initial visibility for OCR batching controls
        try:
            self._toggle_ocr_batching_controls()
        except Exception:
            pass

        # ROI sizing
        roi_frame_local = tk.LabelFrame(content_frame, text="ROI Locality Controls", padx=15, pady=10)
        roi_frame_local.pack(fill='x', padx=20, pady=(10, 0))

        # ROI locality toggle (now inside this section)
        self.roi_locality_var = tk.BooleanVar(value=self.settings['ocr'].get('roi_locality_enabled', False))
        tb.Checkbutton(
            roi_frame_local,
            text="Enable ROI-based OCR locality and batching (uses bubble detection)",
            variable=self.roi_locality_var,
            command=self._toggle_roi_locality_controls,
            bootstyle="round-toggle"
        ).pack(anchor='w', pady=(0,5))

        # ROI padding ratio
        roi_pad_row = tk.Frame(roi_frame_local)
        roi_pad_row.pack(fill='x', pady=5)
        self.roi_pad_row = roi_pad_row
        tk.Label(roi_pad_row, text="ROI Padding Ratio:", width=20, anchor='w').pack(side='left')
        self.roi_padding_ratio_var = tk.DoubleVar(value=float(self.settings['ocr'].get('roi_padding_ratio', 0.08)))
        roi_pad_scale = tk.Scale(
            roi_pad_row,
            from_=0.0,
            to=0.30,
            resolution=0.01,
            orient='horizontal',
            variable=self.roi_padding_ratio_var,
            length=200
        )
        roi_pad_scale.pack(side='left', padx=10)
        tk.Label(roi_pad_row, textvariable=self.roi_padding_ratio_var, width=5).pack(side='left')

        # ROI min side / area
        roi_min_row = tk.Frame(roi_frame_local)
        roi_min_row.pack(fill='x', pady=5)
        self.roi_min_row = roi_min_row
        tk.Label(roi_min_row, text="Min ROI Side:", width=20, anchor='w').pack(side='left')
        self.roi_min_side_var = tk.IntVar(value=int(self.settings['ocr'].get('roi_min_side_px', 12)))
        self.roi_min_side_spin = tb.Spinbox(
            roi_min_row,
            from_=1,
            to=64,
            textvariable=self.roi_min_side_var,
            width=10
        )
        self.roi_min_side_spin.pack(side='left', padx=10)
        tk.Label(roi_min_row, text="px").pack(side='left')

        roi_area_row = tk.Frame(roi_frame_local)
        roi_area_row.pack(fill='x', pady=5)
        self.roi_area_row = roi_area_row
        tk.Label(roi_area_row, text="Min ROI Area:", width=20, anchor='w').pack(side='left')
        self.roi_min_area_var = tk.IntVar(value=int(self.settings['ocr'].get('roi_min_area_px', 100)))
        self.roi_min_area_spin = tb.Spinbox(
            roi_area_row,
            from_=1,
            to=5000,
            textvariable=self.roi_min_area_var,
            width=10
        )
        self.roi_min_area_spin.pack(side='left', padx=10)
        tk.Label(roi_area_row, text="px^2").pack(side='left')

        # ROI max side (0 disables)
        roi_max_row = tk.Frame(roi_frame_local)
        roi_max_row.pack(fill='x', pady=5)
        self.roi_max_row = roi_max_row
        tk.Label(roi_max_row, text="ROI Max Side (0=off):", width=20, anchor='w').pack(side='left')
        self.roi_max_side_var = tk.IntVar(value=int(self.settings['ocr'].get('roi_max_side', 0)))
        self.roi_max_side_spin = tb.Spinbox(
            roi_max_row,
            from_=0,
            to=2048,
            textvariable=self.roi_max_side_var,
            width=10
        )
        self.roi_max_side_spin.pack(side='left', padx=10)

        # Apply initial visibility based on toggle
        self._toggle_roi_locality_controls()

        # AI Bubble Detection Settings
        bubble_frame = tk.LabelFrame(content_frame, text="AI Bubble Detection", padx=15, pady=10)
        bubble_frame.pack(fill='x', padx=20, pady=(10, 0))

        # Enable bubble detection
        self.bubble_detection_enabled = tk.BooleanVar(
            value=self.settings['ocr'].get('bubble_detection_enabled', False)
        )

        bubble_enable_cb = tb.Checkbutton(
            bubble_frame,
            text="Enable AI-powered bubble detection (overrides traditional merging)",
            variable=self.bubble_detection_enabled,
            bootstyle="round-toggle",
            command=self._toggle_bubble_controls
        )
        bubble_enable_cb.pack(anchor='w')


        # Detector type dropdown - PUT THIS DIRECTLY IN bubble_frame
        detector_type_frame = tk.Frame(bubble_frame)
        detector_type_frame.pack(fill='x', pady=(10, 0))

        tk.Label(detector_type_frame, text="Detector:", width=15, anchor='w').pack(side='left')

        # Model mapping
        self.detector_models = {
            'RTEDR_onnx': 'ogkalu/comic-text-and-bubble-detector',
            'RT-DETR': 'ogkalu/comic-text-and-bubble-detector',
            'YOLOv8 Speech': 'ogkalu/comic-speech-bubble-detector-yolov8m',
            'YOLOv8 Text': 'ogkalu/comic-text-segmenter-yolov8m',
            'YOLOv8 Manga': 'ogkalu/manga-text-detector-yolov8s',
            'Custom Model': ''
        }

        # Get saved detector type (default to ONNX backend)
        saved_type = self.settings['ocr'].get('detector_type', 'rtdetr_onnx')
        if saved_type == 'rtdetr_onnx':
            initial_selection = 'RTEDR_onnx'
        elif saved_type == 'rtdetr':
            initial_selection = 'RT-DETR'
        elif saved_type == 'yolo':
            initial_selection = 'YOLOv8 Speech'
        elif saved_type == 'custom':
            initial_selection = 'Custom Model'
        else:
            initial_selection = 'RTEDR_onnx'

        self.detector_type = tk.StringVar(value=initial_selection)

        detector_combo = ttk.Combobox(
            detector_type_frame,
            textvariable=self.detector_type,
            values=list(self.detector_models.keys()),
            state='readonly',
            width=20
        )
        detector_combo.pack(side='left', padx=(10, 0))
        detector_combo.bind('<<ComboboxSelected>>', lambda e: self._on_detector_type_changed())

        # NOW create the settings frame
        self.yolo_settings_frame = tk.LabelFrame(bubble_frame, text="Model Settings", padx=10, pady=5)
        self.rtdetr_settings_frame = self.yolo_settings_frame  # Alias

        # NOW you can create model_frame inside yolo_settings_frame
        model_frame = tk.Frame(self.yolo_settings_frame)
        model_frame.pack(fill='x', pady=(5, 0))

        tk.Label(model_frame, text="Model:", width=12, anchor='w').pack(side='left')

        self.bubble_model_path = tk.StringVar(
            value=self.settings['ocr'].get('bubble_model_path', '')
        )
        self.rtdetr_model_url = self.bubble_model_path  # Alias

        # Style the entry to match GUI theme
        self.bubble_model_entry = tk.Entry(
            model_frame,
            textvariable=self.bubble_model_path,
            width=35,
            state='readonly',
            bg='#2b2b2b',  # Dark background
            fg='#ffffff',  # White text
            insertbackground='#ffffff',  # White cursor
            readonlybackground='#1e1e1e',  # Even darker when readonly
            relief='flat',
            bd=1
        )
        self.bubble_model_entry.pack(side='left', padx=(0, 10))
        self.rtdetr_url_entry = self.bubble_model_entry  # Alias
        
        # Store for compatibility
        self.detector_radio_widgets = [detector_combo]

        # Settings frames
        self.yolo_settings_frame = tk.LabelFrame(bubble_frame, text="Model Settings", padx=10, pady=5)
        self.rtdetr_settings_frame = self.yolo_settings_frame  # Alias

        # Model path/URL
        model_frame = tk.Frame(self.yolo_settings_frame)
        model_frame.pack(fill='x', pady=(5, 0))

        tk.Label(model_frame, text="Model:", width=12, anchor='w').pack(side='left')

        self.bubble_model_path = tk.StringVar(
            value=self.settings['ocr'].get('bubble_model_path', '')
        )
        self.rtdetr_model_url = self.bubble_model_path  # Alias

        self.bubble_model_entry = tk.Entry(
            model_frame,
            textvariable=self.bubble_model_path,
            width=35,
            state='readonly'
        )
        self.bubble_model_entry.pack(side='left', padx=(0, 10))
        self.rtdetr_url_entry = self.bubble_model_entry  # Alias

        self.bubble_browse_btn = tb.Button(
            model_frame,
            text="Browse",
            command=self._browse_bubble_model,
            bootstyle="primary"
        )
        self.bubble_browse_btn.pack(side='left')

        self.bubble_clear_btn = tb.Button(
            model_frame,
            text="Clear",
            command=self._clear_bubble_model,
            bootstyle="secondary"
        )
        self.bubble_clear_btn.pack(side='left', padx=(5, 0))

        # Download and Load buttons
        button_frame = tk.Frame(self.yolo_settings_frame)
        button_frame.pack(fill='x', pady=(10, 0))

        tk.Label(button_frame, text="Actions:", width=12, anchor='w').pack(side='left')

        self.rtdetr_download_btn = tb.Button(
            button_frame,
            text="Download",
            command=self._download_rtdetr_model,
            bootstyle="success"
        )
        self.rtdetr_download_btn.pack(side='left', padx=(0, 5))

        self.rtdetr_load_btn = tb.Button(
            button_frame,
            text="Load Model",
            command=self._load_rtdetr_model,
            bootstyle="primary"
        )
        self.rtdetr_load_btn.pack(side='left')

        self.rtdetr_status_label = tk.Label(
            button_frame,
            text="",
            font=('Arial', 9)
        )
        self.rtdetr_status_label.pack(side='left', padx=(15, 0))

        # RT-DETR Detection classes
        rtdetr_classes_frame = tk.Frame(self.yolo_settings_frame)
        rtdetr_classes_frame.pack(fill='x', pady=(10, 0))

        tk.Label(rtdetr_classes_frame, text="Detect:", width=12, anchor='w').pack(side='left')

        self.detect_empty_bubbles = tk.BooleanVar(
            value=self.settings['ocr'].get('detect_empty_bubbles', True)
        )
        empty_cb = tk.Checkbutton(
            rtdetr_classes_frame,
            text="Empty Bubbles",
            variable=self.detect_empty_bubbles
        )
        empty_cb.pack(side='left', padx=(0, 10))

        self.detect_text_bubbles = tk.BooleanVar(
            value=self.settings['ocr'].get('detect_text_bubbles', True)
        )
        text_cb = tk.Checkbutton(
            rtdetr_classes_frame,
            text="Text Bubbles",
            variable=self.detect_text_bubbles
        )
        text_cb.pack(side='left', padx=(0, 10))

        self.detect_free_text = tk.BooleanVar(
            value=self.settings['ocr'].get('detect_free_text', True)
        )
        free_cb = tk.Checkbutton(
            rtdetr_classes_frame,
            text="Free Text",
            variable=self.detect_free_text
        )
        free_cb.pack(side='left')
        
        self.rtdetr_classes_frame = rtdetr_classes_frame

        # Confidence
        conf_frame = tk.Frame(self.yolo_settings_frame)
        conf_frame.pack(fill='x', pady=(10, 0))

        tk.Label(conf_frame, text="Confidence:", width=12, anchor='w').pack(side='left')

        detector_label = self.detector_type.get()
        default_conf = 0.3 if ('RT-DETR' in detector_label or 'RTEDR_onnx' in detector_label or 'onnx' in detector_label.lower()) else 0.5
        
        self.bubble_confidence = tk.DoubleVar(
            value=self.settings['ocr'].get('bubble_confidence', default_conf)
        )
        self.rtdetr_confidence = self.bubble_confidence

        self.bubble_conf_scale = tk.Scale(
            conf_frame,
            from_=0.0,
            to=0.99,
            resolution=0.01,
            orient='horizontal',
            variable=self.bubble_confidence,
            length=200,
            command=lambda v: self.bubble_conf_label.config(text=f"{float(v):.2f}")
        )
        self.bubble_conf_scale.pack(side='left', padx=(0, 10))
        self.rtdetr_conf_scale = self.bubble_conf_scale

        self.bubble_conf_label = tk.Label(conf_frame, text=f"{self.bubble_confidence.get():.2f}", width=5)
        self.bubble_conf_label.pack(side='left')
        self.rtdetr_conf_label = self.bubble_conf_label

        # Status label
        # YOLO-specific: Max detections (only visible for YOLO)
        self.yolo_maxdet_row = tk.Frame(self.yolo_settings_frame)
        self.yolo_maxdet_row.pack_forget()
        tk.Label(self.yolo_maxdet_row, text="Max detections:", width=12, anchor='w').pack(side='left')
        self.bubble_max_det_yolo_var = tk.IntVar(
            value=self.settings['ocr'].get('bubble_max_detections_yolo', 100)
        )
        tb.Spinbox(
            self.yolo_maxdet_row,
            from_=1,
            to=2000,
            textvariable=self.bubble_max_det_yolo_var,
            width=10
        ).pack(side='left', padx=(0,10))

        self.bubble_status_label = tk.Label(
            bubble_frame,
            text="",
            font=('Arial', 9)
        )
        self.bubble_status_label.pack(anchor='w', pady=(10, 0))

        # Store controls
        self.bubble_controls = [
            detector_combo,
            self.bubble_model_entry,
            self.bubble_browse_btn,
            self.bubble_clear_btn,
            self.bubble_conf_scale,
            self.rtdetr_download_btn,
            self.rtdetr_load_btn
        ]

        self.rtdetr_controls = [
            self.rtdetr_url_entry,
            self.rtdetr_load_btn,
            self.rtdetr_download_btn,
            self.rtdetr_conf_scale,
            empty_cb,
            text_cb,
            free_cb
        ]

        self.yolo_controls = [
            self.bubble_model_entry,
            self.bubble_browse_btn,
            self.bubble_clear_btn,
            self.bubble_conf_scale,
            self.yolo_maxdet_row
        ]

        # Initialize control states
        self._toggle_bubble_controls()

        # Only call detector change after everything is initialized
        if self.bubble_detection_enabled.get():
            try:
                self._on_detector_type_changed()
                self._update_bubble_status()
            except AttributeError:
                # Frames not yet created, skip initialization
                pass

        # Check status after dialog ready
        self.dialog.after(500, self._check_rtdetr_status)
    
    def _on_detector_type_changed(self):
        """Handle detector type change"""
        if not hasattr(self, 'bubble_detection_enabled'):
            return
            
        if not self.bubble_detection_enabled.get():
            self.yolo_settings_frame.pack_forget()
            return
        
        detector = self.detector_type.get()
        
        # Handle different detector types
        if detector == 'Custom Model':
            # Custom model - enable manual entry
            self.bubble_model_path.set(self.settings['ocr'].get('custom_model_path', ''))
            self.bubble_model_entry.config(
                state='normal',
                bg='#2b2b2b',
                readonlybackground='#2b2b2b'
            )
            # Show browse/clear buttons for custom
            self.bubble_browse_btn.pack(side='left')
            self.bubble_clear_btn.pack(side='left', padx=(5, 0))
            # Hide download button
            self.rtdetr_download_btn.pack_forget()
        elif detector in self.detector_models:
            # HuggingFace model
            url = self.detector_models[detector]
            self.bubble_model_path.set(url)
            # Make entry read-only for HuggingFace models
            self.bubble_model_entry.config(
                state='readonly',
                readonlybackground='#1e1e1e'
            )
            # Hide browse/clear buttons for HuggingFace models
            self.bubble_browse_btn.pack_forget()
            self.bubble_clear_btn.pack_forget()
            # Show download button
            self.rtdetr_download_btn.pack(side='left', padx=(0, 5))
        
        # Show/hide RT-DETR specific controls
        if 'RT-DETR' in detector or 'RTEDR_onnx' in detector:
            self.rtdetr_classes_frame.pack(fill='x', pady=(10, 0), after=self.rtdetr_load_btn.master)
            # Hide YOLO-only max det row
            self.yolo_maxdet_row.pack_forget()
        else:
            self.rtdetr_classes_frame.pack_forget()
            # Show YOLO-only max det row for YOLO models
            if 'YOLO' in detector or 'Yolo' in detector or 'yolo' in detector or detector == 'Custom Model':
                self.yolo_maxdet_row.pack(fill='x', pady=(6,0))
            else:
                self.yolo_maxdet_row.pack_forget()
        
        # Always show settings frame
        self.yolo_settings_frame.pack(fill='x', pady=(10, 0))
        
        # Update status
        self._update_bubble_status()

    def _download_rtdetr_model(self):
        """Download selected model"""
        try:
            detector = self.detector_type.get()
            model_url = self.bubble_model_path.get()
            
            self.rtdetr_status_label.config(text="Downloading...", fg='orange')
            self.dialog.update_idletasks()
            
            if 'RTEDR_onnx' in detector:
                from bubble_detector import BubbleDetector
                bd = BubbleDetector()
                if bd.load_rtdetr_onnx_model(model_id=model_url):
                    self.rtdetr_status_label.config(text="✅ Downloaded", fg='green')
                    messagebox.showinfo("Success", f"RTEDR_onnx model downloaded successfully!")
                else:
                    self.rtdetr_status_label.config(text="❌ Failed", fg='red')
                    messagebox.showerror("Error", f"Failed to download RTEDR_onnx model")
            elif 'RT-DETR' in detector:
                # RT-DETR handling (works fine)
                from bubble_detector import BubbleDetector
                bd = BubbleDetector()
                
                if bd.load_rtdetr_model(model_id=model_url):
                    self.rtdetr_status_label.config(text="✅ Downloaded", fg='green')
                    messagebox.showinfo("Success", f"RT-DETR model downloaded successfully!")
                else:
                    self.rtdetr_status_label.config(text="❌ Failed", fg='red')
                    messagebox.showerror("Error", f"Failed to download RT-DETR model")
            else:
                # FIX FOR YOLO: Download to a simpler local path
                from huggingface_hub import hf_hub_download
                import os
                
                # Create models directory
                models_dir = "models"
                os.makedirs(models_dir, exist_ok=True)
                
                # Define simple local filenames
                filename_map = {
                    'ogkalu/comic-speech-bubble-detector-yolov8m': 'comic-speech-bubble-detector.pt',
                    'ogkalu/comic-text-segmenter-yolov8m': 'comic-text-segmenter.pt',
                    'ogkalu/manga-text-detector-yolov8s': 'manga-text-detector.pt'
                }
                
                filename = filename_map.get(model_url, 'model.pt')
                
                # Download to cache first
                cached_path = hf_hub_download(repo_id=model_url, filename=filename)
                
                # Copy to local models directory with simple path
                import shutil
                local_path = os.path.join(models_dir, filename)
                shutil.copy2(cached_path, local_path)
                
                # Set the simple local path instead of the cache path
                self.bubble_model_path.set(local_path)
                self.rtdetr_status_label.config(text="✅ Downloaded", fg='green')
                messagebox.showinfo("Success", f"Model downloaded to:\n{local_path}")
        
        except ImportError:
            self.rtdetr_status_label.config(text="❌ Missing deps", fg='red')
            messagebox.showerror("Error", "Install: pip install huggingface-hub transformers")
        except Exception as e:
            self.rtdetr_status_label.config(text="❌ Error", fg='red')
            messagebox.showerror("Error", f"Download failed: {e}")

    def _check_rtdetr_status(self):
        """Check if model is already loaded"""
        try:
            from bubble_detector import BubbleDetector
            
            if hasattr(self.main_gui, 'manga_tab') and hasattr(self.main_gui.manga_tab, 'translator'):
                translator = self.main_gui.manga_tab.translator
                if hasattr(translator, 'bubble_detector') and translator.bubble_detector:
                    if getattr(translator.bubble_detector, 'rtdetr_onnx_loaded', False):
                        self.rtdetr_status_label.config(text="✅ Loaded", fg='green')
                        return True
                    if getattr(translator.bubble_detector, 'rtdetr_loaded', False):
                        self.rtdetr_status_label.config(text="✅ Loaded", fg='green')
                        return True
                    elif getattr(translator.bubble_detector, 'model_loaded', False):
                        self.rtdetr_status_label.config(text="✅ Loaded", fg='green')
                        return True
            
            self.rtdetr_status_label.config(text="Not loaded", fg='gray')
            return False
            
        except ImportError:
            self.rtdetr_status_label.config(text="❌ Missing deps", fg='red')
            return False
        except Exception:
            self.rtdetr_status_label.config(text="Not loaded", fg='gray')
            return False

    def _load_rtdetr_model(self):
        """Load selected model"""
        try:
            from bubble_detector import BubbleDetector
            
            self.rtdetr_status_label.config(text="Loading...", fg='orange')
            self.dialog.update_idletasks()
            
            bd = BubbleDetector()
            detector = self.detector_type.get()
            model_path = self.bubble_model_path.get()
            
            if 'RTEDR_onnx' in detector:
                # RT-DETR (ONNX) uses repo id directly
                if bd.load_rtdetr_onnx_model(model_id=model_path):
                    self.rtdetr_status_label.config(text="✅ Ready", fg='green')
                    messagebox.showinfo("Success", f"RTEDR_onnx model loaded successfully!")
                else:
                    self.rtdetr_status_label.config(text="❌ Failed", fg='red')
            elif 'RT-DETR' in detector:
                # RT-DETR uses model_id directly
                if bd.load_rtdetr_model(model_id=model_path):
                    self.rtdetr_status_label.config(text="✅ Ready", fg='green')
                    messagebox.showinfo("Success", f"RT-DETR model loaded successfully!")
                else:
                    self.rtdetr_status_label.config(text="❌ Failed", fg='red')
            else:
                # YOLOv8 - CHECK LOCAL MODELS FOLDER FIRST
                if model_path.startswith('ogkalu/'):
                    # It's a HuggingFace ID - check if already downloaded
                    filename_map = {
                        'ogkalu/comic-speech-bubble-detector-yolov8m': 'comic-speech-bubble-detector.pt',
                        'ogkalu/comic-text-segmenter-yolov8m': 'comic-text-segmenter.pt',
                        'ogkalu/manga-text-detector-yolov8s': 'manga-text-detector.pt'
                    }
                    
                    filename = filename_map.get(model_path, 'model.pt')
                    local_path = os.path.join('models', filename)
                    
                    # Check if it exists locally
                    if os.path.exists(local_path):
                        # Use the local file
                        model_path = local_path
                        self.bubble_model_path.set(local_path)  # Update the field
                    else:
                        # Not downloaded yet
                        messagebox.showwarning("Download Required", 
                            f"Model not found locally.\nPlease download it first using the Download button.")
                        self.rtdetr_status_label.config(text="❌ Not downloaded", fg='orange')
                        return
                
                # Now model_path should be a local file
                if not os.path.exists(model_path):
                    messagebox.showerror("Error", f"Model file not found: {model_path}")
                    self.rtdetr_status_label.config(text="❌ File not found", fg='red')
                    return
                
                # Load the YOLOv8 model from local file
                if bd.load_model(model_path):
                    self.rtdetr_status_label.config(text="✅ Ready", fg='green')
                    messagebox.showinfo("Success", f"YOLOv8 model loaded successfully!")
                    
                    # Auto-convert to ONNX if enabled
                    if os.environ.get('AUTO_CONVERT_TO_ONNX', 'true').lower() == 'true':
                        onnx_path = model_path.replace('.pt', '.onnx')
                        if not os.path.exists(onnx_path):
                            if bd.convert_to_onnx(model_path, onnx_path):
                                logger.info(f"✅ Converted to ONNX: {onnx_path}")
                else:
                    self.rtdetr_status_label.config(text="❌ Failed", fg='red')
                
        except ImportError:
            self.rtdetr_status_label.config(text="❌ Missing deps", fg='red')
            messagebox.showerror("Error", "Install transformers: pip install transformers")
        except Exception as e:
            self.rtdetr_status_label.config(text="❌ Error", fg='red')
            messagebox.showerror("Error", f"Failed to load: {e}")
        
    def _toggle_bubble_controls(self):
        """Enable/disable bubble detection controls"""
        enabled = self.bubble_detection_enabled.get()
        
        if enabled:
            # Enable controls
            for widget in self.bubble_controls:
                try:
                    widget.config(state='normal')
                except:
                    pass
            
            # Show/hide frames based on detector type
            self._on_detector_type_changed()
        else:
            # Disable controls
            for widget in self.bubble_controls:
                try:
                    widget.config(state='disabled')
                except:
                    pass
            
            # Hide frames
            self.yolo_settings_frame.pack_forget()
            self.bubble_status_label.config(text="")

    def _browse_bubble_model(self):
        """Browse for model file"""
        from tkinter import filedialog
        
        path = filedialog.askopenfilename(
            title="Select Model File",
            filetypes=[
                ("Model files", "*.pt;*.pth;*.bin;*.safetensors"),
                ("All files", "*.*")
            ]
        )
        
        if path:
            self.bubble_model_path.set(path)
            self._update_bubble_status()

    def _clear_bubble_model(self):
        """Clear selected model"""
        self.bubble_model_path.set("")
        self._update_bubble_status()

    def _update_bubble_status(self):
        """Update bubble model status label"""
        if not self.bubble_detection_enabled.get():
            self.bubble_status_label.config(text="")
            return
        
        detector = self.detector_type.get()
        model_path = self.bubble_model_path.get()
        
        if not model_path:
            self.bubble_status_label.config(text="⚠️ No model selected", fg='orange')
            return
        
        if model_path.startswith("ogkalu/"):
            self.bubble_status_label.config(text=f"📥 {detector} ready to download", fg='blue')
        elif os.path.exists(model_path):
            self.bubble_status_label.config(text="✅ Model file ready", fg='green')
        else:
            self.bubble_status_label.config(text="❌ Model file not found", fg='red')

    def _update_azure_label(self):
        """Update Azure multiplier label"""
        value = self.azure_merge_multiplier.get()
        self.azure_label.config(text=f"{value:.1f}x")

    def _set_azure_multiplier(self, value):
        """Set Azure multiplier from preset"""
        self.azure_merge_multiplier.set(value)
        self._update_azure_label()
    
    def _create_advanced_tab(self, notebook):
        """Create advanced settings tab with all options"""
        frame = ttk.Frame(notebook)
        notebook.add(frame, text="Advanced")
        
        # Main content
        content_frame = tk.Frame(frame)
        content_frame.pack(fill='both', expand=True, padx=5, pady=5)
        
        # Format detection
        detect_frame = tk.LabelFrame(content_frame, text="Format Detection", padx=15, pady=10)
        detect_frame.pack(fill='x', padx=20, pady=20)
        
        self.format_detection = tk.IntVar(value=1 if self.settings['advanced']['format_detection'] else 0)
        tb.Checkbutton(
            detect_frame,
            text="Enable automatic manga format detection (reading direction)",
            variable=self.format_detection,
            bootstyle="round-toggle"
        ).pack(anchor='w')
        
        # Webtoon mode
        webtoon_frame = tk.Frame(detect_frame)
        webtoon_frame.pack(fill='x', pady=(10, 0))
        tk.Label(webtoon_frame, text="Webtoon Mode:", width=20, anchor='w').pack(side='left')
        self.webtoon_mode = tk.StringVar(value=self.settings['advanced']['webtoon_mode'])
        webtoon_combo = ttk.Combobox(
            webtoon_frame,
            textvariable=self.webtoon_mode,
            values=['auto', 'enabled', 'disabled'],
            state='readonly',
            width=15
        )
        webtoon_combo.pack(side='left', padx=10)
        
        # Debug settings
        debug_frame = tk.LabelFrame(content_frame, text="Debug Options", padx=15, pady=10)
        debug_frame.pack(fill='x', padx=20, pady=(0, 20))
        
        self.debug_mode = tk.IntVar(value=1 if self.settings['advanced']['debug_mode'] else 0)
        tb.Checkbutton(
            debug_frame,
            text="Enable debug mode (verbose logging)",
            variable=self.debug_mode,
            bootstyle="round-toggle"
        ).pack(anchor='w')
        
        # New: Concise pipeline logs (reduce noise)
        self.concise_logs_var = tk.BooleanVar(value=bool(self.settings.get('advanced', {}).get('concise_logs', True)))
        def _save_concise():
            try:
                self.settings.setdefault('advanced', {})['concise_logs'] = bool(self.concise_logs_var.get())
                if hasattr(self, 'config'):
                    self.config['manga_settings'] = self.settings
                if hasattr(self.main_gui, 'save_config'):
                    self.main_gui.save_config(show_message=False)
            except Exception:
                pass
        tb.Checkbutton(
            debug_frame,
            text="Concise pipeline logs (reduce noise)",
            variable=self.concise_logs_var,
            command=_save_concise,
            bootstyle="round-toggle"
        ).pack(anchor='w', pady=(5, 0))
        
        self.save_intermediate = tk.IntVar(value=1 if self.settings['advanced']['save_intermediate'] else 0)
        tb.Checkbutton(
            debug_frame,
            text="Save intermediate images (preprocessed, detection overlays)",
            variable=self.save_intermediate,
            bootstyle="round-toggle"
        ).pack(anchor='w', pady=(5, 0))
        
        # Performance settings
        perf_frame = tk.LabelFrame(content_frame, text="Performance", padx=15, pady=10)
        # Defer packing until after memory_frame so this section appears below it
        
        # New: Parallel rendering (per-region overlays)
        self.render_parallel_var = tk.BooleanVar(
            value=self.settings.get('advanced', {}).get('render_parallel', True)
        )
        tb.Checkbutton(
            perf_frame,
            text="Enable parallel rendering (per-region overlays)",
            variable=self.render_parallel_var,
            bootstyle="round-toggle"
        ).pack(anchor='w')
        
        self.parallel_processing = tk.IntVar(value=1 if self.settings['advanced']['parallel_processing'] else 0)
        parallel_cb = tb.Checkbutton(
            perf_frame,
            text="Enable parallel processing (experimental)",
            variable=self.parallel_processing,
            bootstyle="round-toggle",
            command=self._toggle_workers
        )
        parallel_cb.pack(anchor='w')
        
        
        # Max workers
        workers_frame = tk.Frame(perf_frame)
        workers_frame.pack(fill='x', pady=(10, 0))
        self.workers_label = tk.Label(workers_frame, text="Max Workers:", width=20, anchor='w')
        self.workers_label.pack(side='left')
        
        self.max_workers = tk.IntVar(value=self.settings['advanced']['max_workers'])
        self.workers_spinbox = tb.Spinbox(
            workers_frame,
            from_=1,
            to=8,
            textvariable=self.max_workers,
            increment=1,
            width=10
        )
        self.workers_spinbox.pack(side='left', padx=10)
        
        tk.Label(workers_frame, text="(threads for parallel processing)").pack(side='left')
        
        # Initialize workers state
        self._toggle_workers()
        
        # Memory management section
        memory_frame = tk.LabelFrame(content_frame, text="Memory Management", padx=15, pady=10)
        memory_frame.pack(fill='x', padx=20, pady=(10, 0))
        
        # Now pack performance BELOW memory management
        perf_frame.pack(fill='x', padx=20)
        
        # Singleton mode for model instances
        self.use_singleton_models = tk.BooleanVar(
            value=self.settings.get('advanced', {}).get('use_singleton_models', True)
        )
        
        def _toggle_singleton_mode():
            """Disable LOCAL parallel processing options when singleton mode is enabled.
            Note: This does NOT affect parallel API calls (batch translation).
            """
            # Update settings immediately to avoid background preloads
            try:
                if 'advanced' not in self.settings:
                    self.settings['advanced'] = {}
                if self.use_singleton_models.get():
                    # Turn off local parallelism and panel preloads
                    self.settings['advanced']['parallel_processing'] = False
                    self.settings['advanced']['parallel_panel_translation'] = False
                    self.settings['advanced']['preload_local_inpainting_for_panels'] = False
                # Persist to config if available
                if hasattr(self, 'config'):
                    self.config['manga_settings'] = self.settings
                if hasattr(self.main_gui, 'save_config'):
                    self.main_gui.save_config(show_message=False)
            except Exception:
                pass
            
            if self.use_singleton_models.get():
                # Disable LOCAL parallel processing toggles (but NOT API batch translation)
                self.parallel_processing.set(0)
                self.parallel_panel_var.set(False)
                # Disable the UI elements for LOCAL parallel processing
                parallel_cb.config(state='disabled')
                panel_cb.config(state='disabled')
                # Also disable the spinboxes
                self.workers_spinbox.config(state='disabled')
                panel_workers_spinbox.config(state='disabled')
                panel_stagger_spinbox.config(state='disabled')
            else:
                # Re-enable the UI elements
                parallel_cb.config(state='normal')
                panel_cb.config(state='normal')
                # Re-enable spinboxes based on their toggle states
                self._toggle_workers()
                _toggle_panel_controls()
        
        singleton_cb = tb.Checkbutton(
            memory_frame,
            text="Use single model instances (saves RAM, only affects local models)",
            variable=self.use_singleton_models,
            bootstyle="round-toggle",
            command=_toggle_singleton_mode
        )
        singleton_cb.pack(anchor='w')
        
        singleton_note = tk.Label(
            memory_frame,
            text="When enabled: One bubble detector & one inpainter shared across all images.\n"
                 "When disabled: Each thread/image can have its own models (uses more RAM).\n"
                 "✅ Batch API translation remains fully functional with singleton mode enabled.",
            font=('Arial', 9),
            fg='gray',
            justify='left'
        )
        singleton_note.pack(anchor='w', pady=(2, 10), padx=(20, 0))
        
        self.auto_cleanup_models = tk.BooleanVar(
            value=self.settings.get('advanced', {}).get('auto_cleanup_models', False)
        )
        cleanup_cb = tb.Checkbutton(
            memory_frame,
            text="Automatically cleanup models after translation to free RAM",
            variable=self.auto_cleanup_models,
            bootstyle="round-toggle"
        )
        cleanup_cb.pack(anchor='w')
        
        # Unload models after translation (disabled by default)
        self.unload_models_var = tk.BooleanVar(
            value=self.settings.get('advanced', {}).get('unload_models_after_translation', False)
        )
        unload_cb = tb.Checkbutton(
            memory_frame,
            text="Unload models after translation (reset translator instance)",
            variable=self.unload_models_var,
            bootstyle="round-toggle"
        )
        unload_cb.pack(anchor='w', pady=(4,0))
        
        # Add a note about parallel processing
        note_label = tk.Label(
            memory_frame,
            text="Note: When parallel panel translation is enabled, cleanup happens after ALL panels complete.",
            font=('Arial', 9),
            fg='gray',
            wraplength=450
        )
        note_label.pack(anchor='w', pady=(5, 0), padx=(20, 0))

        # Panel-level parallel translation
        panel_frame = tk.LabelFrame(content_frame, text="Parallel Panel Translation", padx=15, pady=10)
        panel_frame.pack(fill='x', padx=20, pady=(10, 0))

        # New: Preload local inpainting for panels (default ON)
        preload_row = tk.Frame(panel_frame)
        preload_row.pack(fill='x', pady=5)
        self.preload_local_panels_var = tk.BooleanVar(
            value=self.settings.get('advanced', {}).get('preload_local_inpainting_for_panels', True)
        )
        tb.Checkbutton(
            preload_row,
            text="Preload local inpainting instances for panel-parallel runs",
            variable=self.preload_local_panels_var,
            bootstyle="round-toggle"
        ).pack(anchor='w')

        self.parallel_panel_var = tk.BooleanVar(
            value=self.settings.get('advanced', {}).get('parallel_panel_translation', False)
        )
        
        def _toggle_panel_controls():
            """Enable/disable panel spinboxes based on panel parallel toggle"""
            if self.parallel_panel_var.get() and not self.use_singleton_models.get():
                panel_workers_spinbox.config(state='normal')
                panel_stagger_spinbox.config(state='normal')
            else:
                panel_workers_spinbox.config(state='disabled')
                panel_stagger_spinbox.config(state='disabled')
        
        panel_cb = tb.Checkbutton(
            panel_frame,
            text="Enable parallel panel translation (process multiple images concurrently)",
            variable=self.parallel_panel_var,
            bootstyle="round-toggle",
            command=_toggle_panel_controls
        )
        panel_cb.pack(anchor='w')
        
        # Inpainting Performance (moved from Inpainting tab)
        inpaint_perf = tk.LabelFrame(perf_frame, text="Inpainting Performance", padx=15, pady=10)
        inpaint_perf.pack(fill='x', padx=0, pady=(10,0))
        inpaint_bs_row = tk.Frame(inpaint_perf)
        inpaint_bs_row.pack(fill='x', pady=5)
        tk.Label(inpaint_bs_row, text="Batch Size:", width=20, anchor='w').pack(side='left')
        self.inpaint_batch_size = getattr(self, 'inpaint_batch_size', tk.IntVar(value=self.settings.get('inpainting', {}).get('batch_size', 10)))
        tb.Spinbox(
            inpaint_bs_row,
            from_=1,
            to=32,
            textvariable=self.inpaint_batch_size,
            width=10
        ).pack(side='left', padx=10)
        tk.Label(inpaint_bs_row, text="(process multiple regions at once)", font=('Arial',9), fg='gray').pack(side='left')
        
        cache_row = tk.Frame(inpaint_perf)
        cache_row.pack(fill='x', pady=5)
        self.enable_cache_var = getattr(self, 'enable_cache_var', tk.BooleanVar(value=self.settings.get('inpainting', {}).get('enable_cache', True)))
        tb.Checkbutton(
            cache_row,
            text="Enable inpainting cache (speeds up repeated processing)",
            variable=self.enable_cache_var,
            bootstyle="round-toggle"
        ).pack(anchor='w')

        panels_row = tk.Frame(panel_frame)
        panels_row.pack(fill='x', pady=5)
        tk.Label(panels_row, text="Max concurrent panels:", width=20, anchor='w').pack(side='left')
        self.panel_max_workers_var = tk.IntVar(
            value=self.settings.get('advanced', {}).get('panel_max_workers', 2)
        )
        panel_workers_spinbox = tb.Spinbox(
            panels_row,
            from_=1,
            to=12,
            textvariable=self.panel_max_workers_var,
            width=10
        )
        panel_workers_spinbox.pack(side='left', padx=10)
        
        # Panel start stagger (ms)
        stagger_row = tk.Frame(panel_frame)
        stagger_row.pack(fill='x', pady=5)
        tk.Label(stagger_row, text="Panel start stagger:", width=20, anchor='w').pack(side='left')
        self.panel_stagger_ms_var = tk.IntVar(
            value=self.settings.get('advanced', {}).get('panel_start_stagger_ms', 30)
        )
        panel_stagger_spinbox = tb.Spinbox(
            stagger_row,
            from_=0,
            to=1000,
            textvariable=self.panel_stagger_ms_var,
            width=10
        )
        panel_stagger_spinbox.pack(side='left', padx=10)
        tk.Label(stagger_row, text="ms").pack(side='left')
        
        # Initialize control states
        _toggle_panel_controls()  # Initialize panel spinbox states
        _toggle_singleton_mode()  # Initialize singleton mode state (may override above)

        # ONNX conversion settings
        onnx_frame = tk.LabelFrame(content_frame, text="ONNX Conversion", padx=15, pady=10)
        onnx_frame.pack(fill='x', padx=20, pady=(10, 0))
        
        self.auto_convert_onnx_var = tk.BooleanVar(value=self.settings['advanced'].get('auto_convert_to_onnx', False))
        self.auto_convert_onnx_bg_var = tk.BooleanVar(value=self.settings['advanced'].get('auto_convert_to_onnx_background', True))
        
        def _toggle_onnx_controls():
            # If auto-convert is off, background toggle should be disabled
            state = 'normal' if self.auto_convert_onnx_var.get() else 'disabled'
            try:
                bg_cb.config(state=state)
            except Exception:
                pass
        
        auto_cb = tb.Checkbutton(
            onnx_frame,
            text="Auto-convert local models to ONNX for faster inference (recommended)",
            variable=self.auto_convert_onnx_var,
            bootstyle="round-toggle",
            command=_toggle_onnx_controls
        )
        auto_cb.pack(anchor='w')
        
        bg_cb = tb.Checkbutton(
            onnx_frame,
            text="Convert in background (non-blocking; switches to ONNX when ready)",
            variable=self.auto_convert_onnx_bg_var,
            bootstyle="round-toggle"
        )
        bg_cb.pack(anchor='w', pady=(5, 0))
        
        _toggle_onnx_controls()
        
        # Model memory optimization (quantization)
        quant_frame = tk.LabelFrame(content_frame, text="Model Memory Optimization", padx=15, pady=10)
        quant_frame.pack(fill='x', padx=20, pady=(10, 0))
        
        self.quantize_models_var = tk.BooleanVar(value=self.settings['advanced'].get('quantize_models', False))
        tb.Checkbutton(
            quant_frame,
            text="Reduce RAM with quantized models (global switch)",
            variable=self.quantize_models_var,
            bootstyle="round-toggle"
        ).pack(anchor='w')
        
        # ONNX quantize sub-toggle
        onnx_row = tk.Frame(quant_frame)
        onnx_row.pack(fill='x', pady=(6, 0))
        self.onnx_quantize_var = tk.BooleanVar(value=self.settings['advanced'].get('onnx_quantize', False))
        tb.Checkbutton(
            onnx_row,
            text="Quantize ONNX models to INT8 (dynamic)",
            variable=self.onnx_quantize_var,
            bootstyle="round-toggle"
        ).pack(side='left')
        tk.Label(onnx_row, text="(lower RAM/CPU; slight accuracy trade-off)", font=('Arial', 9), fg='gray').pack(side='left', padx=8)
        
        # Torch precision dropdown
        precision_row = tk.Frame(quant_frame)
        precision_row.pack(fill='x', pady=(6, 0))
        tk.Label(precision_row, text="Torch precision:", width=20, anchor='w').pack(side='left')
        self.torch_precision_var = tk.StringVar(value=self.settings['advanced'].get('torch_precision', 'fp16'))
        ttk.Combobox(
            precision_row,
            textvariable=self.torch_precision_var,
            values=['fp16', 'fp32', 'auto'],
            state='readonly',
            width=10
        ).pack(side='left', padx=10)
        tk.Label(precision_row, text="(fp16 only, since fp32 is currently bugged)", font=('Arial', 9), fg='gray').pack(side='left')
        
        # Aggressive memory cleanup
        cleanup_frame = tk.LabelFrame(content_frame, text="Memory & Cleanup", padx=15, pady=10)
        cleanup_frame.pack(fill='x', padx=20, pady=(10, 0))
        
        self.force_deep_cleanup_var = tk.BooleanVar(value=self.settings.get('advanced', {}).get('force_deep_cleanup_each_image', False))
        tb.Checkbutton(
            cleanup_frame,
            text="Force deep model cleanup after every image (slowest, lowest RAM)",
            variable=self.force_deep_cleanup_var,
            bootstyle="round-toggle"
        ).pack(anchor='w')
        tk.Label(cleanup_frame, text="Also clears shared caches at batch end.", font=('Arial', 9), fg='gray').pack(anchor='w', padx=(0,0), pady=(2,0))
        
        # RAM cap controls
        ramcap_frame = tk.Frame(cleanup_frame)
        ramcap_frame.pack(fill='x', pady=(10, 0))
        self.ram_cap_enabled_var = tk.BooleanVar(value=self.settings.get('advanced', {}).get('ram_cap_enabled', False))
        tb.Checkbutton(
            ramcap_frame,
            text="Enable RAM cap",
            variable=self.ram_cap_enabled_var,
            bootstyle="round-toggle"
        ).pack(anchor='w')
        
        # RAM cap value
        ramcap_value_row = tk.Frame(cleanup_frame)
        ramcap_value_row.pack(fill='x', pady=5)
        tk.Label(ramcap_value_row, text="Max RAM (MB):", width=20, anchor='w').pack(side='left')
        self.ram_cap_mb_var = tk.IntVar(value=int(self.settings.get('advanced', {}).get('ram_cap_mb', 0) or 0))
        tb.Spinbox(
            ramcap_value_row,
            from_=512,
            to=131072,
            textvariable=self.ram_cap_mb_var,
            width=12
        ).pack(side='left', padx=10)
        tk.Label(ramcap_value_row, text="(0 = disabled)", font=('Arial', 9), fg='gray').pack(side='left')
        
        # RAM cap mode
        ramcap_mode_row = tk.Frame(cleanup_frame)
        ramcap_mode_row.pack(fill='x', pady=(5, 0))
        tk.Label(ramcap_mode_row, text="Cap mode:", width=20, anchor='w').pack(side='left')
        self.ram_cap_mode_var = tk.StringVar(value=self.settings.get('advanced', {}).get('ram_cap_mode', 'soft'))
        ttk.Combobox(
            ramcap_mode_row,
            textvariable=self.ram_cap_mode_var,
            values=['soft', 'hard (Windows only)'],
            state='readonly',
            width=20
        ).pack(side='left', padx=10)
        tk.Label(ramcap_mode_row, text="Soft = clean/trim, Hard = OS-enforced (may OOM)", font=('Arial', 9), fg='gray').pack(side='left')
        
        # Advanced RAM gate tuning
        gate_row = tk.Frame(cleanup_frame)
        gate_row.pack(fill='x', pady=(5, 0))
        tk.Label(gate_row, text="Gate timeout (sec):", width=20, anchor='w').pack(side='left')
        self.ram_gate_timeout_var = tk.DoubleVar(value=float(self.settings.get('advanced', {}).get('ram_gate_timeout_sec', 10.0)))
        tb.Spinbox(
            gate_row,
            from_=2.0,
            to=60.0,
            increment=0.5,
            textvariable=self.ram_gate_timeout_var,
            width=12
        ).pack(side='left', padx=10)
        
        floor_row = tk.Frame(cleanup_frame)
        floor_row.pack(fill='x', pady=(5, 0))
        tk.Label(floor_row, text="Gate floor over baseline (MB):", width=25, anchor='w').pack(side='left')
        self.ram_gate_floor_var = tk.IntVar(value=int(self.settings.get('advanced', {}).get('ram_min_floor_over_baseline_mb', 128)))
        tb.Spinbox(
            floor_row,
            from_=64,
            to=2048,
            textvariable=self.ram_gate_floor_var,
            width=12
        ).pack(side='left', padx=10)

    def _toggle_workers(self):
        """Enable/disable worker settings based on parallel processing toggle"""
        enabled = bool(self.parallel_processing.get())
        self.workers_spinbox.config(state='normal' if enabled else 'disabled')
        self.workers_label.config(fg='white' if enabled else 'gray')

    def _apply_defaults_to_controls(self):
        """Apply default values to all visible Tk variables/controls across tabs without rebuilding the dialog."""
        try:
            # Use current in-memory settings (which we set to defaults above)
            s = self.settings if isinstance(getattr(self, 'settings', None), dict) else self.default_settings
            pre = s.get('preprocessing', {})
            comp = s.get('compression', {})
            ocr = s.get('ocr', {})
            adv = s.get('advanced', {})
            inp = s.get('inpainting', {})
            font = s.get('font_sizing', {})

            # Preprocessing
            if hasattr(self, 'preprocess_enabled'): self.preprocess_enabled.set(bool(pre.get('enabled', False)))
            if hasattr(self, 'auto_detect'): self.auto_detect.set(bool(pre.get('auto_detect_quality', True)))
            if hasattr(self, 'contrast_threshold'): self.contrast_threshold.set(float(pre.get('contrast_threshold', 0.4)))
            if hasattr(self, 'sharpness_threshold'): self.sharpness_threshold.set(float(pre.get('sharpness_threshold', 0.3)))
            if hasattr(self, 'enhancement_strength'): self.enhancement_strength.set(float(pre.get('enhancement_strength', 1.5)))
            if hasattr(self, 'noise_threshold'): self.noise_threshold.set(int(pre.get('noise_threshold', 20)))
            if hasattr(self, 'denoise_strength'): self.denoise_strength.set(int(pre.get('denoise_strength', 10)))
            if hasattr(self, 'max_dimension'): self.max_dimension.set(int(pre.get('max_image_dimension', 2000)))
            if hasattr(self, 'max_pixels'): self.max_pixels.set(int(pre.get('max_image_pixels', 2000000)))
            if hasattr(self, 'chunk_height'): self.chunk_height.set(int(pre.get('chunk_height', 1000)))
            if hasattr(self, 'chunk_overlap'): self.chunk_overlap.set(int(pre.get('chunk_overlap', 100)))
            # Compression
            if hasattr(self, 'compression_enabled_var'): self.compression_enabled_var.set(bool(comp.get('enabled', False)))
            if hasattr(self, 'compression_format_var'): self.compression_format_var.set(str(comp.get('format', 'jpeg')))
            if hasattr(self, 'jpeg_quality_var'): self.jpeg_quality_var.set(int(comp.get('jpeg_quality', 85)))
            if hasattr(self, 'png_level_var'): self.png_level_var.set(int(comp.get('png_compress_level', 6)))
            if hasattr(self, 'webp_quality_var'): self.webp_quality_var.set(int(comp.get('webp_quality', 85)))
            # Tiling
            if hasattr(self, 'inpaint_tiling_enabled'): self.inpaint_tiling_enabled.set(bool(pre.get('inpaint_tiling_enabled', False)))
            if hasattr(self, 'inpaint_tile_size'): self.inpaint_tile_size.set(int(pre.get('inpaint_tile_size', 512)))
            if hasattr(self, 'inpaint_tile_overlap'): self.inpaint_tile_overlap.set(int(pre.get('inpaint_tile_overlap', 64)))

            # OCR basic
            if hasattr(self, 'confidence_threshold'): self.confidence_threshold.set(float(ocr.get('confidence_threshold', 0.7)))
            if hasattr(self, 'detection_mode'): self.detection_mode.set(str(ocr.get('text_detection_mode', 'document')))
            if hasattr(self, 'merge_nearby_threshold'): self.merge_nearby_threshold.set(int(ocr.get('merge_nearby_threshold', 20)))
            if hasattr(self, 'enable_rotation'): self.enable_rotation.set(bool(ocr.get('enable_rotation_correction', True)))

            # Language checkboxes
            try:
                if hasattr(self, 'lang_vars') and isinstance(self.lang_vars, dict):
                    langs = set(ocr.get('language_hints', ['ja', 'ko', 'zh']))
                    for code, var in self.lang_vars.items():
                        var.set(code in langs)
            except Exception:
                pass

            # OCR batching/locality
            if hasattr(self, 'ocr_batch_enabled_var'): self.ocr_batch_enabled_var.set(bool(ocr.get('ocr_batch_enabled', True)))
            if hasattr(self, 'ocr_batch_size_var'): self.ocr_batch_size_var.set(int(ocr.get('ocr_batch_size', 8)))
            if hasattr(self, 'ocr_max_conc_var'): self.ocr_max_conc_var.set(int(ocr.get('ocr_max_concurrency', 2)))
            if hasattr(self, 'roi_locality_var'): self.roi_locality_var.set(bool(ocr.get('roi_locality_enabled', False)))
            if hasattr(self, 'roi_padding_ratio_var'): self.roi_padding_ratio_var.set(float(ocr.get('roi_padding_ratio', 0.08)))
            if hasattr(self, 'roi_min_side_var'): self.roi_min_side_var.set(int(ocr.get('roi_min_side_px', 12)))
            if hasattr(self, 'roi_min_area_var'): self.roi_min_area_var.set(int(ocr.get('roi_min_area_px', 100)))
            if hasattr(self, 'roi_max_side_var'): self.roi_max_side_var.set(int(ocr.get('roi_max_side', 0)))

            # English filters
            if hasattr(self, 'exclude_english_var'): self.exclude_english_var.set(bool(ocr.get('exclude_english_text', False)))
            if hasattr(self, 'english_exclude_threshold'): self.english_exclude_threshold.set(float(ocr.get('english_exclude_threshold', 0.7)))
            if hasattr(self, 'english_exclude_min_chars'): self.english_exclude_min_chars.set(int(ocr.get('english_exclude_min_chars', 4)))
            if hasattr(self, 'english_exclude_short_tokens'): self.english_exclude_short_tokens.set(bool(ocr.get('english_exclude_short_tokens', False)))

            # Azure
            if hasattr(self, 'azure_merge_multiplier'): self.azure_merge_multiplier.set(float(ocr.get('azure_merge_multiplier', 3.0)))
            if hasattr(self, 'azure_reading_order'): self.azure_reading_order.set(str(ocr.get('azure_reading_order', 'natural')))
            if hasattr(self, 'azure_model_version'): self.azure_model_version.set(str(ocr.get('azure_model_version', 'latest')))
            if hasattr(self, 'azure_max_wait'): self.azure_max_wait.set(int(ocr.get('azure_max_wait', 60)))
            if hasattr(self, 'azure_poll_interval'): self.azure_poll_interval.set(float(ocr.get('azure_poll_interval', 0.5)))
            try:
                self._update_azure_label()
            except Exception:
                pass

            # Bubble detector
            if hasattr(self, 'bubble_detection_enabled'): self.bubble_detection_enabled.set(bool(ocr.get('bubble_detection_enabled', False)))
            # Detector type mapping to UI labels
            if hasattr(self, 'detector_type'):
                dt = str(ocr.get('detector_type', 'rtdetr_onnx'))
                if dt == 'rtdetr_onnx': self.detector_type.set('RTEDR_onnx')
                elif dt == 'rtdetr': self.detector_type.set('RT-DETR')
                elif dt == 'yolo': self.detector_type.set('YOLOv8 Speech')
                elif dt == 'custom': self.detector_type.set('Custom Model')
                else: self.detector_type.set('RTEDR_onnx')
            if hasattr(self, 'bubble_model_path'): self.bubble_model_path.set(str(ocr.get('bubble_model_path', '')))
            if hasattr(self, 'bubble_confidence'): self.bubble_confidence.set(float(ocr.get('bubble_confidence', 0.5)))
            if hasattr(self, 'detect_empty_bubbles'): self.detect_empty_bubbles.set(bool(ocr.get('detect_empty_bubbles', True)))
            if hasattr(self, 'detect_text_bubbles'): self.detect_text_bubbles.set(bool(ocr.get('detect_text_bubbles', True)))
            if hasattr(self, 'detect_free_text'): self.detect_free_text.set(bool(ocr.get('detect_free_text', True)))
            if hasattr(self, 'bubble_max_det_yolo_var'): self.bubble_max_det_yolo_var.set(int(ocr.get('bubble_max_detections_yolo', 100)))

            # Inpainting
            if hasattr(self, 'inpaint_batch_size'): self.inpaint_batch_size.set(int(inp.get('batch_size', 1)))
            if hasattr(self, 'enable_cache_var'): self.enable_cache_var.set(bool(inp.get('enable_cache', True)))
            if hasattr(self, 'mask_dilation_var'): self.mask_dilation_var.set(int(s.get('mask_dilation', 0)))
            if hasattr(self, 'use_all_iterations_var'): self.use_all_iterations_var.set(bool(s.get('use_all_iterations', True)))
            if hasattr(self, 'all_iterations_var'): self.all_iterations_var.set(int(s.get('all_iterations', 2)))
            if hasattr(self, 'text_bubble_iterations_var'): self.text_bubble_iterations_var.set(int(s.get('text_bubble_dilation_iterations', 2)))
            if hasattr(self, 'empty_bubble_iterations_var'): self.empty_bubble_iterations_var.set(int(s.get('empty_bubble_dilation_iterations', 3)))
            if hasattr(self, 'free_text_iterations_var'): self.free_text_iterations_var.set(int(s.get('free_text_dilation_iterations', 0)))

            # Advanced
            if hasattr(self, 'format_detection'): self.format_detection.set(1 if adv.get('format_detection', True) else 0)
            if hasattr(self, 'webtoon_mode'): self.webtoon_mode.set(str(adv.get('webtoon_mode', 'auto')))
            if hasattr(self, 'debug_mode'): self.debug_mode.set(1 if adv.get('debug_mode', False) else 0)
            if hasattr(self, 'save_intermediate'): self.save_intermediate.set(1 if adv.get('save_intermediate', False) else 0)
            if hasattr(self, 'parallel_processing'): self.parallel_processing.set(1 if adv.get('parallel_processing', False) else 0)
            if hasattr(self, 'max_workers'): self.max_workers.set(int(adv.get('max_workers', 4)))
            if hasattr(self, 'use_singleton_models'): self.use_singleton_models.set(bool(adv.get('use_singleton_models', True)))
            if hasattr(self, 'auto_cleanup_models'): self.auto_cleanup_models.set(bool(adv.get('auto_cleanup_models', False)))
            if hasattr(self, 'unload_models_var'): self.unload_models_var.set(bool(adv.get('unload_models_after_translation', False)))
            if hasattr(self, 'parallel_panel_var'): self.parallel_panel_var.set(bool(adv.get('parallel_panel_translation', False)))
            if hasattr(self, 'panel_max_workers_var'): self.panel_max_workers_var.set(int(adv.get('panel_max_workers', 2)))
            if hasattr(self, 'panel_stagger_ms_var'): self.panel_stagger_ms_var.set(int(adv.get('panel_start_stagger_ms', 30)))
            # New: preload local inpainting for parallel panels (default True)
            if hasattr(self, 'preload_local_panels_var'): self.preload_local_panels_var.set(bool(adv.get('preload_local_inpainting_for_panels', True)))
            if hasattr(self, 'auto_convert_onnx_var'): self.auto_convert_onnx_var.set(bool(adv.get('auto_convert_to_onnx', False)))
            if hasattr(self, 'auto_convert_onnx_bg_var'): self.auto_convert_onnx_bg_var.set(bool(adv.get('auto_convert_to_onnx_background', True)))
            if hasattr(self, 'quantize_models_var'): self.quantize_models_var.set(bool(adv.get('quantize_models', False)))
            if hasattr(self, 'onnx_quantize_var'): self.onnx_quantize_var.set(bool(adv.get('onnx_quantize', False)))
            if hasattr(self, 'torch_precision_var'): self.torch_precision_var.set(str(adv.get('torch_precision', 'auto')))

            # Font sizing tab
            if hasattr(self, 'font_algorithm_var'): self.font_algorithm_var.set(str(font.get('algorithm', 'smart')))
            if hasattr(self, 'min_font_size_var'): self.min_font_size_var.set(int(font.get('min_size', 10)))
            if hasattr(self, 'max_font_size_var'): self.max_font_size_var.set(int(font.get('max_size', 40)))
            if hasattr(self, 'min_readable_var'): self.min_readable_var.set(int(font.get('min_readable', 14)))
            if hasattr(self, 'prefer_larger_var'): self.prefer_larger_var.set(bool(font.get('prefer_larger', True)))
            if hasattr(self, 'bubble_size_factor_var'): self.bubble_size_factor_var.set(bool(font.get('bubble_size_factor', True)))
            if hasattr(self, 'line_spacing_var'): self.line_spacing_var.set(float(font.get('line_spacing', 1.3)))
            if hasattr(self, 'max_lines_var'): self.max_lines_var.set(int(font.get('max_lines', 10)))
            try:
                if hasattr(self, '_on_font_mode_change'):
                    self._on_font_mode_change()
            except Exception:
                pass

            # Rendering controls (if present in this dialog)
            if hasattr(self, 'font_size_mode_var'): self.font_size_mode_var.set(str(s.get('rendering', {}).get('font_size_mode', 'auto')))
            if hasattr(self, 'fixed_font_size_var'): self.fixed_font_size_var.set(int(s.get('rendering', {}).get('fixed_font_size', 16)))
            if hasattr(self, 'font_scale_var'): self.font_scale_var.set(float(s.get('rendering', {}).get('font_scale', 1.0)))
            if hasattr(self, 'auto_fit_style_var'): self.auto_fit_style_var.set(str(s.get('rendering', {}).get('auto_fit_style', 'balanced')))

            # Cloud API tab
            if hasattr(self, 'cloud_model_var'): self.cloud_model_var.set(str(s.get('cloud_inpaint_model', 'ideogram-v2')))
            if hasattr(self, 'custom_version_var'): self.custom_version_var.set(str(s.get('cloud_custom_version', '')))
            if hasattr(self, 'cloud_prompt_var'): self.cloud_prompt_var.set(str(s.get('cloud_inpaint_prompt', 'clean background, smooth surface')))
            if hasattr(self, 'cloud_negative_prompt_var'): self.cloud_negative_prompt_var.set(str(s.get('cloud_negative_prompt', 'text, writing, letters')))
            if hasattr(self, 'cloud_steps_var'): self.cloud_steps_var.set(int(s.get('cloud_inference_steps', 20)))
            if hasattr(self, 'cloud_timeout_var'): self.cloud_timeout_var.set(int(s.get('cloud_timeout', 60)))

            # Trigger dependent UI updates
            try:
                self._toggle_preprocessing()
            except Exception:
                pass
            try:
                if hasattr(self, '_on_cloud_model_change'):
                    self._on_cloud_model_change()
            except Exception:
                pass
            try:
                self._toggle_iteration_controls()
            except Exception:
                pass
            try:
                self._toggle_roi_locality_controls()
            except Exception:
                pass
            try:
                self._toggle_workers()
            except Exception:
                pass
            
            # Build/attach advanced control for local inpainting preload if not present
            try:
                if not hasattr(self, 'preload_local_panels_var') and hasattr(self, '_create_advanced_tab_ui'):
                    # If there is a helper to build advanced UI, we rely on it. Otherwise, attach to existing advanced frame if available.
                    pass
            except Exception:
                pass
            try:
                if hasattr(self, 'compression_format_combo'):
                    self._toggle_compression_format()
            except Exception:
                pass
            try:
                if hasattr(self, 'detector_type'):
                    self._on_detector_type_changed()
            except Exception:
                pass
            try:
                self.dialog.update_idletasks()
            except Exception:
                pass
        except Exception:
            # Best-effort application only
            pass


    def _set_font_preset(self, preset: str):
        """Apply font sizing preset"""
        if preset == 'small':
            # For manga with small bubbles
            self.font_algorithm_var.set('conservative')
            self.min_font_size_var.set(8)
            self.max_font_size_var.set(24)
            self.min_readable_var.set(12)
            self.prefer_larger_var.set(False)
            self.bubble_size_factor_var.set(True)
            self.line_spacing_var.set(1.2)
            self.max_lines_var.set(8)
        elif preset == 'balanced':
            # Default balanced settings
            self.font_algorithm_var.set('smart')
            self.min_font_size_var.set(10)
            self.max_font_size_var.set(40)
            self.min_readable_var.set(14)
            self.prefer_larger_var.set(True)
            self.bubble_size_factor_var.set(True)
            self.line_spacing_var.set(1.3)
            self.max_lines_var.set(10)
        elif preset == 'large':
            # For maximum readability
            self.font_algorithm_var.set('aggressive')
            self.min_font_size_var.set(14)
            self.max_font_size_var.set(50)
            self.min_readable_var.set(16)
            self.prefer_larger_var.set(True)
            self.bubble_size_factor_var.set(False)
            self.line_spacing_var.set(1.4)
            self.max_lines_var.set(12)
    

    def _save_rendering_settings(self, *args):
        """Auto-save font and rendering settings when controls change"""
        # Don't save during initialization
        if hasattr(self, '_initializing') and self._initializing:
            return
        
        try:
            # Ensure rendering section exists in settings
            if 'rendering' not in self.settings:
                self.settings['rendering'] = {}
            
            # Save font size controls if they exist
            if hasattr(self, 'font_size_mode_var'):
                self.settings['rendering']['font_size_mode'] = self.font_size_mode_var.get()
                self.settings['rendering']['fixed_font_size'] = self.fixed_font_size_var.get()
                self.settings['rendering']['font_scale'] = self.font_scale_var.get()
                self.settings['rendering']['auto_fit_style'] = self.auto_fit_style_var.get()
                
                # Save min/max for auto mode
                if hasattr(self, 'min_font_size_var'):
                    self.settings['rendering']['auto_min_size'] = self.min_font_size_var.get()
                if hasattr(self, 'max_font_size_var'):
                    self.settings['rendering']['auto_max_size'] = self.max_font_size_var.get()
            
            # Update config
            self.config['manga_settings'] = self.settings

            # Mirror only auto max to top-level config for backward compatibility; keep min nested
            try:
                auto_max = self.settings.get('rendering', {}).get('auto_max_size', None)
                if auto_max is not None:
                    self.config['manga_max_font_size'] = int(auto_max)
            except Exception:
                pass
            
            # Save to file immediately
            if hasattr(self.main_gui, 'save_config'):
                self.main_gui.save_config()
                print(f"Auto-saved rendering settings")
                time.sleep(0.1)  # Brief pause for stability
                print("💤 Auto-save pausing briefly for stability")
            
        except Exception as e:
            print(f"Error auto-saving rendering settings: {e}")

    def _save_settings(self):
        """Save all settings including expanded iteration controls"""
        try:
            # Collect all preprocessing settings
            self.settings['preprocessing']['enabled'] = self.preprocess_enabled.get()
            self.settings['preprocessing']['auto_detect_quality'] = self.auto_detect.get()
            self.settings['preprocessing']['contrast_threshold'] = self.contrast_threshold.get()
            self.settings['preprocessing']['sharpness_threshold'] = self.sharpness_threshold.get()
            self.settings['preprocessing']['enhancement_strength'] = self.enhancement_strength.get()
            self.settings['preprocessing']['noise_threshold'] = self.noise_threshold.get()
            self.settings['preprocessing']['denoise_strength'] = self.denoise_strength.get()
            self.settings['preprocessing']['max_image_dimension'] = self.max_dimension.get()
            self.settings['preprocessing']['max_image_pixels'] = self.max_pixels.get()
            self.settings['preprocessing']['chunk_height'] = self.chunk_height.get()
            self.settings['preprocessing']['chunk_overlap'] = self.chunk_overlap.get()
            # Compression (saved separately from preprocessing)
            if 'compression' not in self.settings:
                self.settings['compression'] = {}
            self.settings['compression']['enabled'] = bool(self.compression_enabled_var.get()) if hasattr(self, 'compression_enabled_var') else False
            self.settings['compression']['format'] = str(self.compression_format_var.get()) if hasattr(self, 'compression_format_var') else 'jpeg'
            self.settings['compression']['jpeg_quality'] = int(self.jpeg_quality_var.get()) if hasattr(self, 'jpeg_quality_var') else 85
            self.settings['compression']['png_compress_level'] = int(self.png_level_var.get()) if hasattr(self, 'png_level_var') else 6
            self.settings['compression']['webp_quality'] = int(self.webp_quality_var.get()) if hasattr(self, 'webp_quality_var') else 85
            # TILING SETTINGS - save under preprocessing (primary) and mirror under 'tiling' for backward compatibility
            self.settings['preprocessing']['inpaint_tiling_enabled'] = self.inpaint_tiling_enabled.get()
            self.settings['preprocessing']['inpaint_tile_size'] = self.inpaint_tile_size.get()
            self.settings['preprocessing']['inpaint_tile_overlap'] = self.inpaint_tile_overlap.get()
            # Back-compat mirror
            self.settings['tiling'] = {
                'enabled': self.inpaint_tiling_enabled.get(),
                'tile_size': self.inpaint_tile_size.get(),
                'tile_overlap': self.inpaint_tile_overlap.get()
            }
            
            # OCR settings
            self.settings['ocr']['language_hints'] = [code for code, var in self.lang_vars.items() if var.get()]
            self.settings['ocr']['confidence_threshold'] = self.confidence_threshold.get()
            self.settings['ocr']['text_detection_mode'] = self.detection_mode.get()
            self.settings['ocr']['merge_nearby_threshold'] = self.merge_nearby_threshold.get()
            self.settings['ocr']['enable_rotation_correction'] = self.enable_rotation.get()
            self.settings['ocr']['azure_merge_multiplier'] = self.azure_merge_multiplier.get()
            self.settings['ocr']['azure_reading_order'] = self.azure_reading_order.get()
            self.settings['ocr']['azure_model_version'] = self.azure_model_version.get()
            self.settings['ocr']['azure_max_wait'] = self.azure_max_wait.get()
            self.settings['ocr']['azure_poll_interval'] = self.azure_poll_interval.get()
            self.settings['ocr']['min_text_length'] = self.min_text_length_var.get()
            self.settings['ocr']['exclude_english_text'] = self.exclude_english_var.get()
            self.settings['ocr']['roi_locality_enabled'] = bool(self.roi_locality_var.get()) if hasattr(self, 'roi_locality_var') else True
            # OCR batching & locality
            self.settings['ocr']['ocr_batch_enabled'] = bool(self.ocr_batch_enabled_var.get()) if hasattr(self, 'ocr_batch_enabled_var') else True
            self.settings['ocr']['ocr_batch_size'] = int(self.ocr_batch_size_var.get()) if hasattr(self, 'ocr_batch_size_var') else 8
            self.settings['ocr']['ocr_max_concurrency'] = int(self.ocr_max_conc_var.get()) if hasattr(self, 'ocr_max_conc_var') else 2
            self.settings['ocr']['roi_padding_ratio'] = float(self.roi_padding_ratio_var.get()) if hasattr(self, 'roi_padding_ratio_var') else 0.08
            self.settings['ocr']['roi_min_side_px'] = int(self.roi_min_side_var.get()) if hasattr(self, 'roi_min_side_var') else 12
            self.settings['ocr']['roi_min_area_px'] = int(self.roi_min_area_var.get()) if hasattr(self, 'roi_min_area_var') else 100
            self.settings['ocr']['roi_max_side'] = int(self.roi_max_side_var.get()) if hasattr(self, 'roi_max_side_var') else 0
            self.settings['ocr']['english_exclude_threshold'] = self.english_exclude_threshold.get()
            self.settings['ocr']['english_exclude_min_chars'] = self.english_exclude_min_chars.get()
            self.settings['ocr']['english_exclude_short_tokens'] = self.english_exclude_short_tokens.get()
            
            # Bubble detection settings
            self.settings['ocr']['bubble_detection_enabled'] = self.bubble_detection_enabled.get()
            self.settings['ocr']['bubble_model_path'] = self.bubble_model_path.get()
            self.settings['ocr']['bubble_confidence'] = self.bubble_confidence.get()
            self.settings['ocr']['rtdetr_confidence'] = self.bubble_confidence.get()
            self.settings['ocr']['detect_empty_bubbles'] = self.detect_empty_bubbles.get()
            self.settings['ocr']['detect_text_bubbles'] = self.detect_text_bubbles.get()
            self.settings['ocr']['detect_free_text'] = self.detect_free_text.get()
            self.settings['ocr']['rtdetr_model_url'] = self.bubble_model_path.get()
            self.settings['ocr']['bubble_max_detections_yolo'] = int(self.bubble_max_det_yolo_var.get())
            
            # Save the detector type properly
            if hasattr(self, 'detector_type'):
                detector_display = self.detector_type.get()
                if 'RTEDR_onnx' in detector_display or 'ONNX' in detector_display.upper():
                    self.settings['ocr']['detector_type'] = 'rtdetr_onnx'
                elif 'RT-DETR' in detector_display:
                    self.settings['ocr']['detector_type'] = 'rtdetr'
                elif 'YOLOv8' in detector_display:
                    self.settings['ocr']['detector_type'] = 'yolo'
                elif detector_display == 'Custom Model':
                    self.settings['ocr']['detector_type'] = 'custom'
                    self.settings['ocr']['custom_model_path'] = self.bubble_model_path.get()
                else:
                    self.settings['ocr']['detector_type'] = 'rtdetr_onnx'
            
            # Inpainting settings
            if hasattr(self, 'inpaint_batch_size'):
                if 'inpainting' not in self.settings:
                    self.settings['inpainting'] = {}
                self.settings['inpainting']['batch_size'] = self.inpaint_batch_size.get()
                self.settings['inpainting']['enable_cache'] = self.enable_cache_var.get()
                
                # Save all dilation settings
                self.settings['mask_dilation'] = self.mask_dilation_var.get()
                self.settings['use_all_iterations'] = self.use_all_iterations_var.get()
                self.settings['all_iterations'] = self.all_iterations_var.get()
                self.settings['text_bubble_dilation_iterations'] = self.text_bubble_iterations_var.get()
                self.settings['empty_bubble_dilation_iterations'] = self.empty_bubble_iterations_var.get()
                self.settings['free_text_dilation_iterations'] = self.free_text_iterations_var.get()
                self.settings['auto_iterations'] = self.auto_iterations_var.get()
                
                # Legacy support
                self.settings['bubble_dilation_iterations'] = self.text_bubble_iterations_var.get()
                self.settings['dilation_iterations'] = self.text_bubble_iterations_var.get()
            
            # Advanced settings
            self.settings['advanced']['format_detection'] = bool(self.format_detection.get())
            self.settings['advanced']['webtoon_mode'] = self.webtoon_mode.get()
            self.settings['advanced']['debug_mode'] = bool(self.debug_mode.get())
            self.settings['advanced']['save_intermediate'] = bool(self.save_intermediate.get())
            self.settings['advanced']['parallel_processing'] = bool(self.parallel_processing.get())
            self.settings['advanced']['max_workers'] = self.max_workers.get()
            
            # Save HD strategy settings
            try:
                self.settings['advanced']['hd_strategy'] = str(self.hd_strategy_var.get())
                self.settings['advanced']['hd_strategy_resize_limit'] = int(self.hd_resize_limit_var.get())
                self.settings['advanced']['hd_strategy_crop_margin'] = int(self.hd_crop_margin_var.get())
                self.settings['advanced']['hd_strategy_crop_trigger_size'] = int(self.hd_crop_trigger_var.get())
                # Also reflect into environment for immediate effect in this session
                os.environ['HD_STRATEGY'] = self.settings['advanced']['hd_strategy']
                os.environ['HD_RESIZE_LIMIT'] = str(self.settings['advanced']['hd_strategy_resize_limit'])
                os.environ['HD_CROP_MARGIN'] = str(self.settings['advanced']['hd_strategy_crop_margin'])
                os.environ['HD_CROP_TRIGGER'] = str(self.settings['advanced']['hd_strategy_crop_trigger_size'])
            except Exception:
                pass
            
            # Save parallel rendering toggle
            if hasattr(self, 'render_parallel_var'):
                self.settings['advanced']['render_parallel'] = bool(self.render_parallel_var.get())
            # Panel-level parallel translation settings
            self.settings['advanced']['parallel_panel_translation'] = bool(self.parallel_panel_var.get())
            self.settings['advanced']['panel_max_workers'] = int(self.panel_max_workers_var.get())
            self.settings['advanced']['panel_start_stagger_ms'] = int(self.panel_stagger_ms_var.get())
            # New: preload local inpainting for panels
            if hasattr(self, 'preload_local_panels_var'):
                self.settings['advanced']['preload_local_inpainting_for_panels'] = bool(self.preload_local_panels_var.get())
            
            # Memory management settings
            self.settings['advanced']['use_singleton_models'] = bool(self.use_singleton_models.get())
            self.settings['advanced']['auto_cleanup_models'] = bool(self.auto_cleanup_models.get())
            self.settings['advanced']['unload_models_after_translation'] = bool(getattr(self, 'unload_models_var', tk.BooleanVar(value=False)).get())
            
            # ONNX auto-convert settings (persist and apply to environment)
            if hasattr(self, 'auto_convert_onnx_var'):
                self.settings['advanced']['auto_convert_to_onnx'] = bool(self.auto_convert_onnx_var.get())
                os.environ['AUTO_CONVERT_TO_ONNX'] = 'true' if self.auto_convert_onnx_var.get() else 'false'
            if hasattr(self, 'auto_convert_onnx_bg_var'):
                self.settings['advanced']['auto_convert_to_onnx_background'] = bool(self.auto_convert_onnx_bg_var.get())
                os.environ['AUTO_CONVERT_TO_ONNX_BACKGROUND'] = 'true' if self.auto_convert_onnx_bg_var.get() else 'false'
            
            # Quantization toggles and precision
            if hasattr(self, 'quantize_models_var'):
                self.settings['advanced']['quantize_models'] = bool(self.quantize_models_var.get())
                os.environ['MODEL_QUANTIZE'] = 'true' if self.quantize_models_var.get() else 'false'
            if hasattr(self, 'onnx_quantize_var'):
                self.settings['advanced']['onnx_quantize'] = bool(self.onnx_quantize_var.get())
                os.environ['ONNX_QUANTIZE'] = 'true' if self.onnx_quantize_var.get() else 'false'
            if hasattr(self, 'torch_precision_var'):
                self.settings['advanced']['torch_precision'] = str(self.torch_precision_var.get())
                os.environ['TORCH_PRECISION'] = self.settings['advanced']['torch_precision']
            
            # Memory cleanup toggle
            if hasattr(self, 'force_deep_cleanup_var'):
                if 'advanced' not in self.settings:
                    self.settings['advanced'] = {}
                self.settings['advanced']['force_deep_cleanup_each_image'] = bool(self.force_deep_cleanup_var.get())
            # RAM cap settings
            if hasattr(self, 'ram_cap_enabled_var'):
                self.settings['advanced']['ram_cap_enabled'] = bool(self.ram_cap_enabled_var.get())
            if hasattr(self, 'ram_cap_mb_var'):
                try:
                    self.settings['advanced']['ram_cap_mb'] = int(self.ram_cap_mb_var.get())
                except Exception:
                    self.settings['advanced']['ram_cap_mb'] = 0
            if hasattr(self, 'ram_cap_mode_var'):
                mode = self.ram_cap_mode_var.get()
                if mode not in ['soft', 'hard (Windows only)']:
                    mode = 'soft'
                # Normalize to 'soft' or 'hard'
                self.settings['advanced']['ram_cap_mode'] = 'hard' if mode.startswith('hard') else 'soft'
            if hasattr(self, 'ram_gate_timeout_var'):
                try:
                    self.settings['advanced']['ram_gate_timeout_sec'] = float(self.ram_gate_timeout_var.get())
                except Exception:
                    self.settings['advanced']['ram_gate_timeout_sec'] = 10.0
            if hasattr(self, 'ram_gate_floor_var'):
                try:
                    self.settings['advanced']['ram_min_floor_over_baseline_mb'] = int(self.ram_gate_floor_var.get())
                except Exception:
                    self.settings['advanced']['ram_min_floor_over_baseline_mb'] = 128
            
            # Cloud API settings
            if hasattr(self, 'cloud_model_var'):
                self.settings['cloud_inpaint_model'] = self.cloud_model_var.get()
                self.settings['cloud_custom_version'] = self.custom_version_var.get()
                self.settings['cloud_inpaint_prompt'] = self.cloud_prompt_var.get()
                self.settings['cloud_negative_prompt'] = self.cloud_negative_prompt_var.get()
                self.settings['cloud_inference_steps'] = self.cloud_steps_var.get()
                self.settings['cloud_timeout'] = self.cloud_timeout_var.get()
            
            # Font sizing settings from Font Sizing tab
            if hasattr(self, 'font_algorithm_var'):
                if 'font_sizing' not in self.settings:
                    self.settings['font_sizing'] = {}
                self.settings['font_sizing']['algorithm'] = self.font_algorithm_var.get()
                self.settings['font_sizing']['min_size'] = self.min_font_size_var.get()
                self.settings['font_sizing']['max_size'] = self.max_font_size_var.get()
                self.settings['font_sizing']['min_readable'] = self.min_readable_var.get()
                self.settings['font_sizing']['prefer_larger'] = self.prefer_larger_var.get()
                self.settings['font_sizing']['bubble_size_factor'] = self.bubble_size_factor_var.get()
                self.settings['font_sizing']['line_spacing'] = self.line_spacing_var.get()
                self.settings['font_sizing']['max_lines'] = self.max_lines_var.get()
            
            # SAVE FONT SIZE CONTROLS FROM RENDERING (if they exist)
            if hasattr(self, 'font_size_mode_var'):
                if 'rendering' not in self.settings:
                    self.settings['rendering'] = {}
                
                self.settings['rendering']['font_size_mode'] = self.font_size_mode_var.get()
                self.settings['rendering']['fixed_font_size'] = self.fixed_font_size_var.get()
                self.settings['rendering']['font_scale'] = self.font_scale_var.get()
                self.settings['rendering']['auto_min_size'] = self.min_font_size_var.get() if hasattr(self, 'min_font_size_var') else 10
                self.settings['rendering']['auto_max_size'] = self.max_font_size_var.get() if hasattr(self, 'max_font_size_var') else 28
                self.settings['rendering']['auto_fit_style'] = self.auto_fit_style_var.get()
            
            # Clear bubble detector cache to force reload with new settings
            if hasattr(self.main_gui, 'manga_tab') and hasattr(self.main_gui.manga_tab, 'translator'):
                if hasattr(self.main_gui.manga_tab.translator, 'bubble_detector'):
                    self.main_gui.manga_tab.translator.bubble_detector = None
            
            # Save to config
            self.config['manga_settings'] = self.settings
            
            # Save to file - using the correct method name
            try:
                if hasattr(self.main_gui, 'save_config'):
                    self.main_gui.save_config()
                    print("Settings saved successfully via save_config")
                    time.sleep(0.1)  # Brief pause for stability
                    print("💤 Main settings save pausing briefly for stability")
                elif hasattr(self.main_gui, 'save_configuration'):
                    self.main_gui.save_configuration()
                    print("Settings saved successfully via save_configuration")
                else:
                    print("Warning: No save method found on main_gui")
                    # Try direct save as fallback
                    if hasattr(self.main_gui, 'config_file'):
                        import json
                        with open(self.main_gui.config_file, 'w') as f:
                            json.dump(self.config, f, indent=2)
                        print("Settings saved directly to config file")
            except Exception as e:
                print(f"Error saving configuration: {e}")
                from tkinter import messagebox
                messagebox.showerror("Save Error", f"Failed to save settings: {e}")
            
            # Call callback if provided
            if self.callback:
                try:
                    self.callback(self.settings)
                except Exception as e:
                    print(f"Error in callback: {e}")
            
            # Close dialog with cleanup
            try:
                if hasattr(self.dialog, '_cleanup_scrolling'):
                    self.dialog._cleanup_scrolling()
                self.dialog.destroy()
            except Exception as e:
                print(f"Error closing dialog: {e}")
                self.dialog.destroy()
                
        except Exception as e:
            print(f"Critical error in _save_settings: {e}")
            from tkinter import messagebox
            messagebox.showerror("Save Error", f"Failed to save settings: {e}")

    def _reset_defaults(self):
        """Reset by removing manga_settings from config and reinitializing the dialog."""
        from tkinter import messagebox
        if not messagebox.askyesno("Reset Settings", "Reset all manga settings to defaults?\nThis will remove custom manga settings from config.json."):
            return
        # Remove manga_settings key to force defaults
        try:
            if isinstance(self.config, dict) and 'manga_settings' in self.config:
                del self.config['manga_settings']
        except Exception:
            pass
        # Persist changes
        try:
            if hasattr(self.main_gui, 'save_config'):
                self.main_gui.save_config()
            elif hasattr(self.main_gui, 'save_configuration'):
                self.main_gui.save_configuration()
            elif hasattr(self.main_gui, 'config_file') and isinstance(self.main_gui.config_file, str):
                with open(self.main_gui.config_file, 'w', encoding='utf-8') as f:
                    import json
                    json.dump(self.config, f, ensure_ascii=False, indent=2)
        except Exception:
            try:
                if hasattr(self.main_gui, 'CONFIG_FILE') and isinstance(self.main_gui.CONFIG_FILE, str):
                    with open(self.main_gui.CONFIG_FILE, 'w', encoding='utf-8') as f:
                        import json
                        json.dump(self.config, f, ensure_ascii=False, indent=2)
            except Exception:
                pass
        # Close and reopen dialog so defaults apply
        try:
            if hasattr(self.dialog, '_cleanup_scrolling'):
                self.dialog._cleanup_scrolling()
        except Exception:
            pass
        try:
            self.dialog.destroy()
        except Exception:
            pass
        try:
            MangaSettingsDialog(parent=self.parent, main_gui=self.main_gui, config=self.config, callback=self.callback)
        except Exception:
            try:
                messagebox.showinfo("Reset", "Settings reset. Please reopen the dialog.")
            except Exception:
                pass

    def _cancel(self):
        """Cancel without saving"""
        if hasattr(self.dialog, '_cleanup_scrolling'):
            self.dialog._cleanup_scrolling()
        self.dialog.destroy()