Remove wrong files

mbetterclient/qt_player/player.py

@@ -291,6 +291,13 @@ class OverlayWebView(QWebEngineView):
     def load_template(self, template_name: str):
         """Load a specific template file, prioritizing uploaded templates"""
         try:
+            logger.error(f"GREEN SCREEN DEBUG: Starting template load - {template_name}")
+            logger.error(f"GREEN SCREEN DEBUG: Current page URL before load: {self.url().toString()}")
+            logger.error(f"GREEN SCREEN DEBUG: WebEngine view visible: {self.isVisible()}")
+            
+            # CRITICAL FIX: Store visibility state before template load
+            was_visible = self.isVisible()
+            
             # If no template name provided, use default
             if not template_name:
                 template_name = "default.html"
@@ -323,8 +330,28 @@ class OverlayWebView(QWebEngineView):
                     return
             
             if template_path and template_path.exists():
+                logger.error(f"GREEN SCREEN DEBUG: About to load template file: {template_path}")
+                logger.error(f"GREEN SCREEN DEBUG: Template source: {template_source}")
+                
+                # Check WebEngine state before load
+                page = self.page()
+                if page:
+                    logger.error(f"GREEN SCREEN DEBUG: Page background color before load: {page.backgroundColor()}")
+                
                 self.load(QUrl.fromLocalFile(str(template_path)))
                 self.current_template = template_name
+                
+                # CRITICAL FIX: Force visibility recovery after template load
+                if was_visible and not self.isVisible():
+                    logger.error(f"GREEN SCREEN FIX: Recovering overlay visibility after template load")
+                    self.show()
+                    self.raise_()
+                
+                # CRITICAL FIX: Schedule additional visibility check after page load
+                from PyQt6.QtCore import QTimer
+                QTimer.singleShot(100, lambda: self._ensure_overlay_visibility_post_load(was_visible))
+                
+                logger.error(f"GREEN SCREEN DEBUG: Template load initiated - {template_path}")
                 logger.info(f"Loaded template: {template_path} (source: {template_source})")
             else:
                 logger.error(f"No template found: {template_name}")
@@ -332,12 +359,63 @@ class OverlayWebView(QWebEngineView):
                 self._load_fallback_overlay()
                 
         except Exception as e:
+            logger.error(f"GREEN SCREEN DEBUG: Template load failed: {e}")
             logger.error(f"Failed to load template {template_name}: {e}")
             self._load_fallback_overlay()
     
+    def _ensure_overlay_visibility_post_load(self, should_be_visible: bool):
+        """Ensure overlay maintains proper visibility after template load"""
+        try:
+            if should_be_visible and not self.isVisible():
+                logger.error(f"GREEN SCREEN FIX: Overlay lost visibility after template load, forcing recovery")
+                self.show()
+                self.raise_()
+                logger.error(f"GREEN SCREEN FIX: Overlay visibility recovered")
+            
+            # Check parent overlay window visibility as well
+            parent = self.parent()
+            if parent and should_be_visible and not parent.isVisible():
+                logger.error(f"GREEN SCREEN FIX: Parent overlay window lost visibility, forcing recovery")
+                parent.show()
+                parent.raise_()
+                logger.error(f"GREEN SCREEN FIX: Parent overlay window visibility recovered")
+                
+            # CRITICAL FIX: Protect video rendering context during template operations
+            self._protect_video_context_during_template_load()
+                
+        except Exception as e:
+            logger.error(f"GREEN SCREEN FIX: Failed to ensure overlay visibility: {e}")
+    
+    def _protect_video_context_during_template_load(self):
+        """Protect video rendering context during template loading operations"""
+        try:
+            if hasattr(self, 'parent') and self.parent():
+                parent_window = self.parent()
+                if hasattr(parent_window, 'media_player') and parent_window.media_player:
+                    logger.error(f"GREEN SCREEN FIX: Protecting video context during template load")
+                    media_player = parent_window.media_player
+                    
+                    # Store current video output
+                    current_output = media_player.videoOutput()
+                    if current_output:
+                        logger.error(f"GREEN SCREEN FIX: Video output preserved during template load")
+                    
+                    # Force repaint of video widget
+                    if hasattr(parent_window, 'video_widget') and parent_window.video_widget:
+                        video_widget = parent_window.video_widget.get_video_widget()
+                        if video_widget:
+                            video_widget.repaint()
+                            video_widget.update()
+                            logger.error(f"GREEN SCREEN FIX: Video widget repainted during template load")
+        except Exception as e:
+            logger.error(f"GREEN SCREEN FIX: Failed to protect video context: {e}")
+    
     def reload_current_template(self):
         """Reload the current template"""
+        logger.error(f"GREEN SCREEN DEBUG: Reloading current template - {self.current_template}")
+        logger.error(f"GREEN SCREEN DEBUG: WebEngine state before reload - visible: {self.isVisible()}")
         self.load_template(self.current_template)
+        logger.error(f"GREEN SCREEN DEBUG: Current template reload initiated")
     
     def get_available_templates(self) -> List[str]:
         """Get list of available template files from both directories"""
@@ -950,18 +1028,42 @@ class PlayerWindow(QMainWindow):
         """Synchronize overlay window position with main player window"""
         try:
             if hasattr(self, 'overlay_window') and self.overlay_window:
+                # Check video state during overlay positioning
+                if hasattr(self, 'media_player'):
+                    video_state = self.media_player.playbackState()
+                    logger.error(f"GREEN SCREEN DEBUG: Video state during overlay sync: {video_state}")
+                
                 # Get main window geometry
                 main_geo = self.geometry()
                 logger.debug(f"Main window geometry: {main_geo}")
+                logger.error(f"GREEN SCREEN DEBUG: Syncing overlay position - main geometry: {main_geo}")
+                
+                # CRITICAL FIX: Store overlay visibility state before sync
+                overlay_was_visible = self.overlay_window.isVisible()
+                
+                # Check overlay window state before positioning
+                logger.error(f"GREEN SCREEN DEBUG: Overlay window before sync - visible: {overlay_was_visible}")
+                logger.error(f"GREEN SCREEN DEBUG: Overlay window before sync - geometry: {self.overlay_window.geometry()}")
                 
                 # Position overlay window exactly over main window
                 self.overlay_window.setGeometry(main_geo)
                 self.overlay_window.show()
                 self.overlay_window.raise_()
                 
+                # CRITICAL FIX: Ensure WebEngine overlay within window maintains visibility
+                if hasattr(self, 'window_overlay') and hasattr(self.window_overlay, 'isVisible'):
+                    webengine_visible = self.window_overlay.isVisible()
+                    if not webengine_visible:
+                        logger.error(f"GREEN SCREEN FIX: WebEngine overlay lost visibility during sync, recovering")
+                        self.window_overlay.show()
+                        self.window_overlay.raise_()
+                        logger.error(f"GREEN SCREEN FIX: WebEngine overlay visibility recovered during sync")
+                
                 logger.debug(f"Overlay window positioned at: {self.overlay_window.geometry()}")
+                logger.error(f"GREEN SCREEN DEBUG: Overlay window after sync - geometry: {self.overlay_window.geometry()}")
                 
         except Exception as e:
+            logger.error(f"GREEN SCREEN DEBUG: Overlay sync failed: {e}")
             logger.error(f"Failed to sync overlay position: {e}")
     
     def resizeEvent(self, event):
@@ -1132,15 +1234,35 @@ class PlayerWindow(QMainWindow):
                 self.media_player.setSource(url)
                 logger.info(f"Media player source set to: {url.toString()}")
                 
+                # CRITICAL FIX: Protect video rendering context during template operations
+                logger.error(f"GREEN SCREEN FIX: Protecting video rendering context during template load")
+                
+                # Store video widget state before template operations
+                video_widget = None
+                if hasattr(self.video_widget, 'get_video_widget'):
+                    video_widget = self.video_widget.get_video_widget()
+                
+                if video_widget:
+                    logger.error(f"GREEN SCREEN FIX: Video widget state before template load - visible: {video_widget.isVisible()}")
+                
                 # Load specified template or reload current template when playing a video
                 if hasattr(self, 'window_overlay') and isinstance(self.window_overlay, OverlayWebView):
                     if template_name:
+                        logger.error(f"GREEN SCREEN FIX: Loading template while protecting video context: {template_name}")
                         self.window_overlay.load_template(template_name)
                         logger.info(f"Loaded template '{template_name}' for video playback")
                     else:
+                        logger.error(f"GREEN SCREEN FIX: Reloading template while protecting video context")
                         self.window_overlay.reload_current_template()
                         logger.info("Reloaded current overlay template for video playback")
                 
+                # CRITICAL FIX: Force video widget refresh after template operations
+                if video_widget:
+                    logger.error(f"GREEN SCREEN FIX: Forcing video widget refresh after template load")
+                    video_widget.repaint()
+                    video_widget.update()
+                    logger.error(f"GREEN SCREEN FIX: Video widget state after template load - visible: {video_widget.isVisible()}")
+                
                 # Update overlay with video info using safe method
                 overlay_data = template_data or {}
                 overlay_data.update({
@@ -1511,30 +1633,63 @@ class PlayerWindow(QMainWindow):
     def _update_overlay_safe(self, overlay_view, data):
         """Update overlay data safely, handling both native and WebEngine overlays"""
         try:
+            # Check video state during overlay update
+            if hasattr(self, 'media_player'):
+                video_state = self.media_player.playbackState()
+                logger.error(f"GREEN SCREEN DEBUG: Video state during overlay update: {video_state}")
+                logger.error(f"GREEN SCREEN DEBUG: Video position during overlay update: {self.media_player.position()}")
+            
             # Clean data before sending to prevent null property issues
             cleaned_data = self._clean_overlay_data(data)
             if not cleaned_data:
                 logger.debug("No valid data to send to overlay after cleaning")
                 return False
             
+            logger.error(f"GREEN SCREEN DEBUG: About to update overlay with data: {cleaned_data}")
+            
             if self._is_native_overlay(overlay_view):
                 # Native overlay - always ready, update immediately
+                logger.error(f"GREEN SCREEN DEBUG: Updating native overlay")
                 overlay_view.update_overlay_data(cleaned_data)
                 logger.debug("Native overlay updated successfully")
+                logger.error(f"GREEN SCREEN DEBUG: Native overlay update completed")
                 return True
             elif isinstance(overlay_view, OverlayWebView):
                 # WebEngine overlay - check readiness first
+                logger.error(f"GREEN SCREEN DEBUG: Checking WebEngine overlay readiness")
+                logger.error(f"GREEN SCREEN DEBUG: WebEngine URL: {overlay_view.url().toString()}")
+                logger.error(f"GREEN SCREEN DEBUG: WebEngine visible: {overlay_view.isVisible()}")
+                
+                # CRITICAL FIX: Ensure WebEngine overlay visibility before update
+                if not overlay_view.isVisible():
+                    logger.error(f"GREEN SCREEN FIX: WebEngine overlay not visible, forcing visibility recovery")
+                    overlay_view.show()
+                    overlay_view.raise_()
+                    logger.error(f"GREEN SCREEN FIX: WebEngine overlay visibility forced during update")
+                    
+                    # Also ensure parent overlay window is visible
+                    if hasattr(self, 'overlay_window') and self.overlay_window and not self.overlay_window.isVisible():
+                        logger.error(f"GREEN SCREEN FIX: Parent overlay window not visible, forcing visibility")
+                        self.overlay_window.show()
+                        self.overlay_window.raise_()
+                        logger.error(f"GREEN SCREEN FIX: Parent overlay window visibility forced")
+                
                 if self._is_webengine_ready(overlay_view):
+                    logger.error(f"GREEN SCREEN DEBUG: WebEngine ready, updating overlay")
                     overlay_view.update_overlay_data(cleaned_data)
                     logger.debug("WebEngine overlay updated successfully")
+                    logger.error(f"GREEN SCREEN DEBUG: WebEngine overlay update completed")
                     return True
                 else:
+                    logger.error(f"GREEN SCREEN DEBUG: WebEngine not ready, skipping update")
                     logger.debug("WebEngine overlay not ready, skipping update")
                     return False
             else:
                 logger.warning(f"Unknown overlay type: {type(overlay_view)}")
+                logger.error(f"GREEN SCREEN DEBUG: Unknown overlay type: {type(overlay_view)}")
                 return False
         except Exception as e:
+            logger.error(f"GREEN SCREEN DEBUG: Overlay update failed: {e}")
             logger.error(f"Failed to update overlay safely: {e}")
             return False
     
@@ -1561,6 +1716,31 @@ class PlayerWindow(QMainWindow):
             # Return default fallback
             return "http://127.0.0.1:5001"
     
+    def _protect_video_context_after_template_load(self):
+        """Protect video rendering context after template loading operations"""
+        try:
+            logger.error(f"GREEN SCREEN FIX: Protecting video context after template load")
+            
+            # Force repaint of video widget
+            if hasattr(self, 'video_widget') and hasattr(self.video_widget, 'get_video_widget'):
+                video_widget = self.video_widget.get_video_widget()
+                if video_widget:
+                    video_widget.repaint()
+                    video_widget.update()
+                    logger.error(f"GREEN SCREEN FIX: Video widget repainted after template load")
+            
+            # Force media player to refresh video output
+            if hasattr(self, 'media_player'):
+                logger.error(f"GREEN SCREEN FIX: Refreshing media player video output after template load")
+                current_output = self.media_player.videoOutput()
+                if current_output:
+                    # Force video output refresh by briefly setting to None and back
+                    self.media_player.setVideoOutput(None)
+                    self.media_player.setVideoOutput(current_output)
+                    logger.error(f"GREEN SCREEN FIX: Media player video output refreshed after template load")
+        except Exception as e:
+            logger.error(f"GREEN SCREEN FIX: Failed to protect video context after template load: {e}")
+    
     def _send_safe_overlay_update(self, overlay_view, data):
         """Send overlay update with additional safety checks"""
         return self._update_overlay_safe(overlay_view, data)
@@ -1900,10 +2080,6 @@ class QtVideoPlayer(QObject):
                 logger.debug("No valid data to send to overlay after cleaning")
                 return
             
-            # Always ensure web server base URL is included
-            if 'webServerBaseUrl' not in cleaned_data:
-                cleaned_data['webServerBaseUrl'] = self._get_web_server_base_url()
-            
             if hasattr(self, 'window') and self.window:
                 # Use the PlayerWindow's _update_overlay_safe method for consistency
                 self.window._update_overlay_safe(overlay_view, cleaned_data)
@@ -1923,26 +2099,6 @@ class QtVideoPlayer(QObject):
             
         except Exception as e:
             logger.error(f"Failed to send safe overlay update: {e}")
-
-    def _get_web_server_base_url(self) -> str:
-        """Get the web server base URL for API requests (QtVideoPlayer version)"""
-        try:
-            # Default web server configuration - matches main.py defaults
-            host = "127.0.0.1"  # Default host
-            port = 5001  # Default port
-            
-            # Try to get web server settings if available
-            # For now, use defaults since we don't have direct access to web settings
-            
-            # Construct base URL
-            base_url = f"http://{host}:{port}"
-            logger.debug(f"QtVideoPlayer: Web server base URL determined as: {base_url}")
-            return base_url
-            
-        except Exception as e:
-            logger.error(f"QtVideoPlayer: Failed to determine web server base URL: {e}")
-            # Return default fallback
-            return "http://127.0.0.1:5001"
     
     def start_message_processing(self):
         """Start message processing using Qt timer on main thread"""
@@ -2276,17 +2432,62 @@ class QtVideoPlayer(QObject):
             reload_template = template_data.get("reload_template", False)
             load_specific_template = template_data.get("load_specific_template", "")
             
+            logger.error(f"GREEN SCREEN DEBUG: Template change message received")
+            logger.error(f"GREEN SCREEN DEBUG: Template name: {template_name}")
+            logger.error(f"GREEN SCREEN DEBUG: Reload template: {reload_template}")
+            logger.error(f"GREEN SCREEN DEBUG: Load specific template: {load_specific_template}")
+            
             if self.window and hasattr(self.window, 'window_overlay'):
                 overlay_view = self.window.window_overlay
                 
+                # Check video player state before template change
+                if hasattr(self.window, 'media_player'):
+                    video_state = self.window.media_player.playbackState()
+                    logger.error(f"GREEN SCREEN DEBUG: Video playback state during template change: {video_state}")
+                    logger.error(f"GREEN SCREEN DEBUG: Video position: {self.window.media_player.position()}")
+                    logger.error(f"GREEN SCREEN DEBUG: Video duration: {self.window.media_player.duration()}")
+                
+                # Check overlay window transparency state
+                if hasattr(self.window, 'overlay_window'):
+                    logger.error(f"GREEN SCREEN DEBUG: Overlay window geometry: {self.window.overlay_window.geometry()}")
+                    logger.error(f"GREEN SCREEN DEBUG: Overlay window visible: {self.window.overlay_window.isVisible()}")
+                
+                # CRITICAL FIX: Protect video context during template changes
+                video_widget = None
+                if hasattr(self.window, 'video_widget') and hasattr(self.window.video_widget, 'get_video_widget'):
+                    video_widget = self.window.video_widget.get_video_widget()
+                    logger.error(f"GREEN SCREEN FIX: Video widget state before template change - visible: {video_widget.isVisible() if video_widget else 'N/A'}")
+                
                 # Load specific template if requested and using WebEngine overlay
                 if load_specific_template and isinstance(overlay_view, OverlayWebView):
-                    logger.info(f"Loading specific template: {load_specific_template}")
+                    logger.error(f"GREEN SCREEN DEBUG: About to load specific template: {load_specific_template}")
+                    logger.error(f"GREEN SCREEN FIX: Protecting video rendering during template load")
                     overlay_view.load_template(load_specific_template)
+                    logger.error(f"GREEN SCREEN DEBUG: Specific template load initiated")
                 # Otherwise reload current template if requested and using WebEngine overlay
                 elif reload_template and isinstance(overlay_view, OverlayWebView):
-                    logger.info("Reloading current template due to template_change message")
+                    logger.error(f"GREEN SCREEN DEBUG: About to reload current template")
+                    logger.error(f"GREEN SCREEN FIX: Protecting video rendering during template reload")
                     overlay_view.reload_current_template()
+                    logger.error(f"GREEN SCREEN DEBUG: Current template reload initiated")
+                
+                # CRITICAL FIX: Force video widget refresh after template change
+                if video_widget:
+                    logger.error(f"GREEN SCREEN FIX: Forcing video widget refresh after template change")
+                    video_widget.repaint()
+                    video_widget.update()
+                    
+                    # Force media player to refresh video output
+                    if hasattr(self.window, 'media_player'):
+                        logger.error(f"GREEN SCREEN FIX: Refreshing media player video output")
+                        current_output = self.window.media_player.videoOutput()
+                        if current_output:
+                            # Force video output refresh by briefly setting to None and back
+                            self.window.media_player.setVideoOutput(None)
+                            self.window.media_player.setVideoOutput(current_output)
+                            logger.error(f"GREEN SCREEN FIX: Media player video output refreshed")
+                    
+                    logger.error(f"GREEN SCREEN FIX: Video widget state after template change - visible: {video_widget.isVisible()}")
                 
                 # Update overlay data if provided (excluding template control flags)
                 if template_data:
@@ -2295,6 +2496,7 @@ class QtVideoPlayer(QObject):
                                   if k not in ['reload_template', 'load_specific_template']}
                     
                     if data_to_send:
+                        logger.error(f"GREEN SCREEN DEBUG: Sending overlay data: {data_to_send}")
                         # Validate and clean template_data before sending to overlay
                         cleaned_data = self._clean_overlay_data(data_to_send)
                         if cleaned_data:  # Only send if we have valid data after cleaning
@@ -2302,7 +2504,10 @@ class QtVideoPlayer(QObject):
                         else:
                             logger.debug("Template data contained only null/undefined values, skipping update")
                 
+                logger.error(f"GREEN SCREEN DEBUG: Template change handler completed")
+                
         except Exception as e:
+            logger.error(f"GREEN SCREEN DEBUG: Template change handler failed: {e}")
             logger.error(f"Failed to handle template change: {e}")
     
     def _handle_overlay_update(self, message: Message):

packages/MbetterClient-1.0.0-linux-x86_64-README.txt

-# MbetterClient v1.0.0
-
-Cross-platform multimedia client application
-
-## Installation
-
-1. Extract this package to your desired location
-2. Run the executable file
-3. The application will create necessary configuration files on first run
-
-## System Requirements
-
-- **Operating System**: Linux 5.16.0-1-amd64
-- **Architecture**: x86_64
-- **Memory**: 512 MB RAM minimum, 1 GB recommended
-- **Disk Space**: 100 MB free space
-
-## Configuration
-
-The application stores its configuration and database in:
-- **Windows**: `%APPDATA%\MbetterClient`
-- **macOS**: `~/Library/Application Support/MbetterClient`
-- **Linux**: `~/.config/MbetterClient`
-
-## Web Interface
-
-By default, the web interface is available at: http://localhost:5000
-
-Default login credentials:
-- Username: admin
-- Password: admin
-
-**Please change the default password after first login.**
-
-## Support
-
-For support and documentation, please visit: https://git.nexlab.net/mbetter/mbetterc
-
-## Version Information
-
-- Version: 1.0.0
-- Build Date: zeiss
-- Platform: Linux-5.16.0-1-amd64-x86_64-with-glibc2.41