screenoverlay 0.5.0__tar.gz → 0.6.1__tar.gz

{screenoverlay-0.5.0 → screenoverlay-0.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: screenoverlay
-Version: 0.5.0
+Version: 0.6.1
 Summary: Cross-platform screen overlay with blur, black, white, and custom modes
 Home-page: https://github.com/pekay-ai/screenoverlay
 Author: Pekay

{screenoverlay-0.5.0 → screenoverlay-0.6.1}/screenoverlay/__init__.py

@@ -5,7 +5,7 @@ Provides blur, black, white, and custom color overlays with minimal latency
 
 from .overlay import NativeBlurOverlay as Overlay
 
-__version__ = '0.5.0'
+__version__ = '0.6.0'
 __author__ = 'Pekay'
 __all__ = ['Overlay']
 

{screenoverlay-0.5.0 → screenoverlay-0.6.1}/screenoverlay/overlay.py

@@ -2,17 +2,14 @@
 """
 Native Blur Overlay - Uses OS-native blur effects
 No screen capture, no permissions needed, instant appearance
+
+Single-process architecture using Tkinter's update() for non-blocking operation.
 """
 
 import tkinter as tk
 import platform
 import sys
 import os
-import threading
-from multiprocessing import Process, Queue
-import time
-import atexit
-import signal
 
 # Try to import screeninfo for multi-monitor support
 try:
@@ -65,154 +62,170 @@ class NativeBlurOverlay:
         
         self.root = None
         self.windows = []  # List to hold multiple windows for multi-monitor
-        self._timer_id = None
-        self._process = None
-        self._command_queue = None
-        
-        # Register cleanup on exit to prevent orphaned processes
-        atexit.register(self._cleanup_on_exit)
-        
-    def _cleanup_on_exit(self):
-        """Cleanup overlay process on program exit"""
-        if self._process is not None and self._process.is_alive():
-            try:
-                # Try graceful stop first
-                if self._command_queue is not None:
-                    try:
-                        self._command_queue.put('stop')
-                    except:
-                        pass
-                
-                # Wait briefly
-                self._process.join(timeout=0.5)
-                
-                # Force kill if still alive
-                if self._process.is_alive():
-                    self._process.terminate()
-                    self._process.join(timeout=0.5)
-                    
-                # Last resort - force kill
-                if self._process.is_alive():
-                    self._process.kill()
-            except:
-                pass
+        self._is_visible = False
+        self._last_update_time = 0  # Throttle update() calls
         
     def start(self):
         """
-        Start the overlay process with show/hide control.
+        Initialize the overlay windows.
         Call this once at app startup.
         
-        After calling start(), use show() and hide() to control visibility instantly.
+        After calling start(), use show() and hide() to control visibility instantly,
+        and call update() regularly in your main loop to keep the overlay responsive.
         
-        Example for ScreenStop:
+        Example:
             overlay = Overlay(mode='blur', blur_strength=4)
             overlay.start()  # Initialize (call once)
             
-            overlay.show()   # Show overlay (instant)
-            time.sleep(2)
-            overlay.hide()   # Hide overlay (instant)
-            overlay.show()   # Show again
+            while True:
+                overlay.show()      # Show overlay (instant)
+                time.sleep(2)
+                overlay.hide()      # Hide overlay (instant)
+                overlay.update()    # Keep overlay responsive (call regularly!)
             
             overlay.stop()   # Cleanup when done
         """
-        if self._process is not None:
-            return
+        if self.root is not None:
+            return  # Already started
         
-        self._command_queue = Queue()
-        self._process = Process(target=self._run_process, args=(self._command_queue,), daemon=True)
-        self._process.start()
+        # Create windows for all monitors
+        self._create_windows()
         
-        # Wait a bit for process to initialize
-        time.sleep(0.3)
+        # Hide all windows initially
+        for win in self.windows:
+            win.withdraw()
+        
+        self._is_visible = False
     
     def show(self):
-        """Show the overlay (instant, ~1ms)"""
-        if self._command_queue is not None:
-            self._command_queue.put('show')
+        """Show the overlay (instant, <1ms)"""
+        import traceback
+        print(f"\n🔴 OVERLAY.SHOW() CALLED! Stack trace:")
+        traceback.print_stack()
+        
+        if self.root is None:
+            # Auto-start if not started yet
+            self.start()
+        
+        if not self._is_visible:
+            for win in self.windows:
+                try:
+                    win.deiconify()
+                    win.attributes('-topmost', True)  # Re-enable topmost when showing
+                    win.lift()
+                except Exception as e:
+                    print(f"Warning: Failed to show window: {e}")
+            self._is_visible = True
+            print(f"✅ OVERLAY IS NOW VISIBLE\n")
     
     def hide(self):
-        """
-        Hide the overlay and restart for next use (100% reliable, prevents ghost windows)
+        """Hide the overlay by DESTROYING and RECREATING it (prevents ghost windows/CPU leaks)"""
+        import traceback
+        print(f"\n⚪ OVERLAY.HIDE() CALLED! Stack trace:")
+        traceback.print_stack()
         
-        This method:
-        1. Hides the overlay instantly (user sees clear screen ~1ms)
-        2. Stops the overlay process completely (kills any ghost windows)
-        3. Starts a fresh overlay ready for next show() (happens in background ~300ms)
+        if self.root is None:
+            return  # Not started yet
         
-        This "restart on hide" approach guarantees zero ghost windows by giving
-        each detection cycle a fresh overlay process, at the cost of ~300ms 
-        startup time that happens during safe periods (when screen is clear).
-        """
-        if self._command_queue is not None:
-            # Hide first (instant for user)
-            self._command_queue.put('hide')
+        if self._is_visible:
+            # COMPLETE DESTRUCTION - no lingering windows or events!
+            print(f"🗑️ DESTROYING overlay completely...")
+            try:
+                # Just destroy root - it will destroy all child windows automatically
+                if self.root:
+                    try:
+                        self.root.destroy()
+                    except Exception as e:
+                        print(f"Warning: destroy() failed: {e} (might already be destroyed)")
+            except Exception as e:
+                print(f"Warning: Failed to destroy overlay: {e}")
+            
+            self.root = None
+            self.windows = []
+            self._is_visible = False
+            print(f"✅ OVERLAY DESTROYED\n")
+            
+            # SAFETY CHECK: Verify system is clean before recreating
+            print(f"🔍 SAFETY CHECK: Verifying clean state...")
+            if self.root is not None:
+                print(f"⚠️ WARNING: self.root is not None after destroy! Force clearing...")
+                self.root = None
+            if len(self.windows) > 0:
+                print(f"⚠️ WARNING: self.windows has {len(self.windows)} entries after destroy! Force clearing...")
+                self.windows = []
+            if self._is_visible:
+                print(f"⚠️ WARNING: _is_visible is True after destroy! Force clearing...")
+                self._is_visible = False
             
-            # Stop the process completely to prevent ghost windows
-            self.stop()
+            # Small delay to let Tkinter/macOS fully cleanup
+            import time
+            time.sleep(0.01)  # 10ms delay for cleanup
+            print(f"✅ SYSTEM CLEAN\n")
             
-            # Start fresh overlay for next show() (happens in background)
+            # RECREATE FRESH for next show()
+            print(f"♻️ RECREATING fresh overlay...")
             self.start()
+            print(f"✅ FRESH OVERLAY READY (hidden)\n")
+    
+    def update(self):
+        """
+        Keep overlay responsive - call this regularly in your main loop!
+        
+        This processes Tkinter events and keeps the windows responsive.
+        Without calling this, the overlay will freeze.
+        
+        Example:
+            while True:
+                detect_something()
+                if detected:
+                    overlay.show()
+                else:
+                    overlay.hide()
+                overlay.update()  # ← Call this every loop iteration!
+                time.sleep(0.1)
+        """
+        if self.root is not None:
+            try:
+                import time
+                current_time = time.time()
+                
+                # Throttle: only update every 100ms (10 FPS) to reduce CPU load
+                # This prevents excessive event processing while keeping UI responsive
+                if current_time - self._last_update_time < 0.1:
+                    return  # Skip this update
+                
+                self._last_update_time = current_time
+                
+                # Defensive check: verify window state matches _is_visible flag
+                for win in self.windows:
+                    try:
+                        actual_state = win.winfo_viewable()
+                        if actual_state and not self._is_visible:
+                            print(f"⚠️ BUG DETECTED: Window is visible but _is_visible=False! Force hiding...")
+                            win.attributes('-topmost', False)
+                            win.withdraw()
+                        elif not actual_state and self._is_visible:
+                            print(f"⚠️ BUG DETECTED: Window is hidden but _is_visible=True! Syncing flag...")
+                            self._is_visible = False
+                    except Exception as e:
+                        pass  # Ignore errors in defensive check
+                
+                # Process Tkinter events
+                self.root.update()
+            except Exception as e:
+                print(f"Warning: Update failed: {e}")
     
     def stop(self):
         """Stop and cleanup the overlay completely"""
-        if self._command_queue is not None:
-            self._command_queue.put('stop')
-        
-        if self._process is not None:
-            self._process.join(timeout=2.0)
-            if self._process.is_alive():
-                self._process.terminate()
-            self._process = None
-        
-        self._command_queue = None
-    
-    def _run_process(self, command_queue):
-        """Run overlay in separate process with command queue"""
-        try:
-            # Create windows for all monitors
-            self._create_windows()
-            
-            # Hide all windows initially
-            for win in self.windows:
-                win.withdraw()
-            
-            # Process commands from queue
-            def check_commands():
-                try:
-                    while not command_queue.empty():
-                        cmd = command_queue.get_nowait()
-                        if cmd == 'show':
-                            for win in self.windows:
-                                try:
-                                    win.deiconify()
-                                    win.lift()
-                                except Exception as e:
-                                    print(f"Warning: Failed to show window: {e}")
-                        elif cmd == 'hide':
-                            for win in self.windows:
-                                try:
-                                    win.withdraw()
-                                except Exception as e:
-                                    print(f"Warning: Failed to hide window: {e}")
-                        elif cmd == 'stop':
-                            self.root.quit()
-                            return
-                except Exception as e:
-                    print(f"Warning: Command queue error: {e}")
-                
-                # Check again in 10ms
-                self.root.after(10, check_commands)
-            
-            # Start command checker
-            check_commands()
-            
-            # Run mainloop
-            self.root.mainloop()
-            
-        except Exception as e:
-            print(f"Overlay process error: {e}")
-        finally:
-            os._exit(0)
+        if self.root is not None:
+            try:
+                self.root.quit()
+                self.root.destroy()
+            except:
+                pass
+            self.root = None
+            self.windows = []
+            self._is_visible = False
     
     def _get_monitors(self):
         """Get information about all monitors"""
@@ -274,52 +287,9 @@ class NativeBlurOverlay:
         if self.apply_blur:
             self._apply_native_blur_to_window(window)
         
-        # Bind escape key to exit (only on primary window)
+        # Bind escape key to hide (only on primary window)
         if window == self.root:
-            window.bind('<Escape>', lambda e: self.kill_completely())
-            window.focus_set()
-    
-    def _create_window(self):
-        """Internal method to create and configure the Tkinter window"""
-        self.root = tk.Tk()
-        
-        # Remove window decorations
-        self.root.overrideredirect(True)
-        self.root.attributes('-topmost', True)
-        
-        # Set background color (tint)
-        bg_color = f'#{self.color_tint[0]:02x}{self.color_tint[1]:02x}{self.color_tint[2]:02x}'
-        self.root.configure(bg=bg_color)
-        
-        # Set opacity
-        self.root.attributes('-alpha', self.opacity)
-        
-        # Full screen
-        screen_width = self.root.winfo_screenwidth()
-        screen_height = self.root.winfo_screenheight()
-        self.root.geometry(f"{screen_width}x{screen_height}+0+0")
-        
-        # Apply native blur effect based on OS (only if mode is 'blur')
-        if self.apply_blur:
-            self._apply_native_blur()
-        
-        # Bind escape key to exit
-        self.root.bind('<Escape>', lambda e: self.kill_completely())
-        self.root.focus_set()
-    
-    def activate(self, duration=5):
-        """Show native blur overlay and exit after duration"""
-        self._create_windows()  # Use multi-monitor aware method
-        
-        # Auto-exit timer
-        self._timer_id = self.root.after(int(duration * 1000), self.kill_completely)
-        
-        # Show window
-        self.root.mainloop()
-        
-    def _apply_native_blur(self):
-        """Apply OS-native backdrop blur effect to root window (legacy method)"""
-        self._apply_native_blur_to_window(self.root)
+            window.bind('<Escape>', lambda e: self.hide())
     
     def _apply_native_blur_to_window(self, window):
         """Apply OS-native backdrop blur effect to a specific window"""
@@ -331,10 +301,6 @@ class NativeBlurOverlay:
             self._apply_windows_blur_to_window(window)
         elif system == 'Linux':
             self._apply_linux_blur_to_window(window)
-            
-    def _apply_macos_blur(self):
-        """Apply macOS NSVisualEffectView blur (legacy method)"""
-        self._apply_macos_blur_to_window(self.root)
     
     def _apply_macos_blur_to_window(self, window):
         """Apply macOS NSVisualEffectView blur to a specific window"""
@@ -359,17 +325,17 @@ class NativeBlurOverlay:
                 from Cocoa import NSMakeRect
                 
                 # Get all windows and find ours
-                for window in NSApp.windows():
-                    if window.isVisible():
+                for ns_window in NSApp.windows():
+                    if ns_window.isVisible():
                         # Create visual effect view
-                        frame = window.contentView().frame()
+                        frame = ns_window.contentView().frame()
                         effect_view = NSVisualEffectView.alloc().initWithFrame_(frame)
                         effect_view.setBlendingMode_(NSVisualEffectBlendingModeBehindWindow)
                         effect_view.setMaterial_(NSVisualEffectMaterialDark)
                         effect_view.setState_(1)  # Active state
                         
                         # Add as subview
-                        window.contentView().addSubview_positioned_relativeTo_(
+                        ns_window.contentView().addSubview_positioned_relativeTo_(
                             effect_view, 0, None
                         )
                         break
@@ -380,10 +346,6 @@ class NativeBlurOverlay:
             print("pyobjc not available, install with: pip install pyobjc-framework-Cocoa")
         except Exception as e:
             print(f"macOS blur effect failed: {e}")
-            
-    def _apply_windows_blur(self):
-        """Apply Windows Acrylic/Blur effect (legacy method)"""
-        self._apply_windows_blur_to_window(self.root)
     
     def _apply_windows_blur_to_window(self, window):
         """Apply Windows Acrylic/Blur effect to a specific window"""
@@ -446,10 +408,6 @@ class NativeBlurOverlay:
             # Blur effect failed, but window will still work (just without blur)
             print(f"Note: Windows blur effect unavailable: {e}")
             print("Overlay will work but without native blur effect")
-            
-    def _apply_linux_blur(self):
-        """Apply Linux compositor blur (X11/Wayland) (legacy method)"""
-        self._apply_linux_blur_to_window(self.root)
     
     def _apply_linux_blur_to_window(self, window):
         """Apply Linux compositor blur (X11/Wayland) to a specific window"""
@@ -465,18 +423,31 @@ class NativeBlurOverlay:
         except Exception as e:
             print(f"Linux blur effect hint failed: {e}")
     
-    def kill_completely(self):
-        """Exit the overlay completely (for activate() backward compatibility)"""
-        try:
-            if self.root:
-                self.root.quit()
-                self.root.destroy()
-        except:
-            pass
+    # Backward compatibility methods
+    def activate(self, duration=5):
+        """
+        Show overlay for a fixed duration and then exit (blocking).
+        
+        This is the legacy API for backward compatibility.
+        For new code, use start() + show()/hide() + update() instead.
+        """
+        self.start()
+        self.show()
+        
+        # Schedule hide and cleanup
+        self.root.after(int(duration * 1000), self._deactivate_and_exit)
         
-        # Only call os._exit if we're in activate() mode (has timer)
-        if self._timer_id is not None:
-            os._exit(0)
+        # Run mainloop (blocking)
+        self.root.mainloop()
+    
+    def _deactivate_and_exit(self):
+        """Helper for activate() - hide and exit"""
+        self.hide()
+        self.stop()
+
+
+# Alias for convenience
+Overlay = NativeBlurOverlay
 
 
 if __name__ == "__main__":
@@ -490,20 +461,19 @@ if __name__ == "__main__":
     
     print(f"Testing mode='{mode}' for 3 seconds...")
     print("Available modes: blur, black, white, custom")
-    print("Usage: python NativeBlurOverlay.py [mode]")
+    print("Usage: python overlay.py [mode]")
     print()
     
     if mode == 'blur':
-        overlay = NativeBlurOverlay(mode='blur', blur_strength=4)
+        overlay = Overlay(mode='blur', blur_strength=4)
     elif mode == 'black':
-        overlay = NativeBlurOverlay(mode='black')
+        overlay = Overlay(mode='black')
     elif mode == 'white':
-        overlay = NativeBlurOverlay(mode='white')
+        overlay = Overlay(mode='white')
     elif mode == 'custom':
-        overlay = NativeBlurOverlay(mode='custom', opacity=0.7, color_tint=(255, 0, 0))  # Red example
+        overlay = Overlay(mode='custom', opacity=0.7, color_tint=(255, 0, 0))  # Red example
     else:
         print(f"Unknown mode: {mode}")
         sys.exit(1)
     
     overlay.activate(duration=3)
-

{screenoverlay-0.5.0 → screenoverlay-0.6.1}/screenoverlay.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: screenoverlay
-Version: 0.5.0
+Version: 0.6.1
 Summary: Cross-platform screen overlay with blur, black, white, and custom modes
 Home-page: https://github.com/pekay-ai/screenoverlay
 Author: Pekay

{screenoverlay-0.5.0 → screenoverlay-0.6.1}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r", encoding="utf-8") as fh:
 
 setup(
     name="screenoverlay",
-    version="0.5.0",
+    version="0.6.1",
     author="Pekay",
     author_email="ppnicky@gmail.com",
     description="Cross-platform screen overlay with blur, black, white, and custom modes",