screenoverlay 0.2.1__py3-none-any.whl → 0.3.0__py3-none-any.whl

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.2.1'
+__version__ = '0.3.0'
 __author__ = 'Pekay'
 __all__ = ['Overlay']
 

screenoverlay/overlay.py

@@ -8,11 +8,6 @@ import tkinter as tk
 import platform
 import sys
 import os
-import threading
-from multiprocessing import Process, Queue
-import time
-import atexit
-import signal
 
 
 class NativeBlurOverlay:
@@ -56,124 +51,37 @@ class NativeBlurOverlay:
         
         self.root = None
         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
         
     def start(self):
         """
-        Start the overlay process with show/hide control.
-        Call this once at app startup.
+        Start the overlay indefinitely (non-blocking, runs until stop() is called)
         
-        After calling start(), use show() and hide() to control visibility instantly.
-        
-        Example for ScreenStop:
-            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
-            
-            overlay.stop()   # Cleanup when done
+        For ScreenStop integration, run this in a separate process:
+            from multiprocessing import Process
+            p = Process(target=overlay.start)
+            p.start()
+            # Later: p.terminate()
         """
-        if self._process is not None:
-            return
-        
-        self._command_queue = Queue()
-        self._process = Process(target=self._run_process, args=(self._command_queue,), daemon=True)
-        self._process.start()
-        
-        # Wait a bit for process to initialize
-        time.sleep(0.3)
-    
-    def show(self):
-        """Show the overlay (instant, ~1ms)"""
-        if self._command_queue is not None:
-            self._command_queue.put('show')
-    
-    def hide(self):
-        """Hide the overlay (instant, ~1ms)"""
-        if self._command_queue is not None:
-            self._command_queue.put('hide')
+        self._create_window()
+        self.root.mainloop()
     
     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 window
-            self._create_window()
-            self.root.withdraw()  # Start hidden
-            
-            # Process commands from queue
-            def check_commands():
-                try:
-                    while not command_queue.empty():
-                        cmd = command_queue.get_nowait()
-                        if cmd == 'show':
-                            self.root.deiconify()
-                            self.root.lift()
-                        elif cmd == 'hide':
-                            self.root.withdraw()
-                        elif cmd == 'stop':
-                            self.root.quit()
-                            return
-                except:
-                    pass
-                
-                # 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)
+        """Stop and close the overlay"""
+        if self._timer_id is not None:
+            try:
+                self.root.after_cancel(self._timer_id)
+                self._timer_id = None
+            except:
+                pass
+        if self.root is not None:
+            try:
+                self.root.quit()
+                self.root.destroy()
+            except:
+                pass
+            self.root = None
+        # Exit the process cleanly
+        os._exit(0)
     
     def _create_window(self):
         """Internal method to create and configure the Tkinter window"""
@@ -346,7 +254,7 @@ class NativeBlurOverlay:
             print(f"Linux blur effect hint failed: {e}")
     
     def kill_completely(self):
-        """Exit the overlay completely (for activate() backward compatibility)"""
+        """Exit the overlay completely"""
         try:
             if self.root:
                 self.root.quit()
@@ -354,9 +262,7 @@ class NativeBlurOverlay:
         except:
             pass
         
-        # Only call os._exit if we're in activate() mode (has timer)
-        if self._timer_id is not None:
-            os._exit(0)
+        os._exit(0)
 
 
 if __name__ == "__main__":

{screenoverlay-0.2.1.dist-info → screenoverlay-0.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: screenoverlay
-Version: 0.2.1
+Version: 0.3.0
 Summary: Cross-platform screen overlay with blur, black, white, and custom modes
 Home-page: https://github.com/pekay-ai/screenoverlay
 Author: Pekay
@@ -109,33 +109,27 @@ Overlay(mode='custom', color_tint=(255, 100, 100), opacity=0.7).activate()
 
 Press `ESC` to dismiss the overlay early.
 
-### Instant Show/Hide Control ⭐ **NEW**
+### Manual Start/Stop Control
 
-For real-time applications that need instant toggling with **zero latency** (like ScreenStop):
+For apps that need to control overlay lifetime (like ScreenStop):
 
 ```python
 from screenoverlay import Overlay
-import time
-
-# Initialize once (one-time ~300ms setup)
-overlay = Overlay(mode='blur', blur_strength=4)
-overlay.start()
+from multiprocessing import Process
 
-# Then show/hide instantly (~0.1ms each)
-overlay.show()  # Overlay appears instantly
-time.sleep(2)
-overlay.hide()  # Overlay disappears instantly
+def run_overlay():
+    overlay = Overlay(mode='blur', blur_strength=4)
+    overlay.start()  # Runs indefinitely
 
-overlay.show()  # Show again - still instant!
-time.sleep(2)
-overlay.hide()
+# Start overlay in separate process
+overlay_process = Process(target=run_overlay)
+overlay_process.start()
 
-# Cleanup when done
-overlay.stop()
+# Later, stop it
+overlay_process.terminate()
+overlay_process.join()
 ```
 
-**Performance:** `show()` and `hide()` take **~0.1ms** - virtually instant! Perfect for real-time control.
-
 **See [`examples/`](examples/) folder for more use cases!**
 
 ---
@@ -249,45 +243,32 @@ overlay.activate(duration=5)
 
 **Note:** Press `ESC` to dismiss early.
 
-### `start()` Method ⭐ **NEW**
+### `start()` Method
 
-Initialize the overlay process for instant show/hide control.
+Start overlay indefinitely (runs until stopped).
 
 ```python
 overlay.start()
 ```
 
-**Important:** Call this once at app startup. It creates a background process (~300ms). After initialization, use `show()` and `hide()` for instant toggling.
-
-### `show()` Method ⭐ **NEW**
-
-Show the overlay instantly (~0.1ms).
-
-```python
-overlay.show()
-```
-
-**Performance:** Virtually instant - no subprocess creation, just a queue message.
-
-### `hide()` Method ⭐ **NEW**
-
-Hide the overlay instantly (~0.1ms).
+**Important:** This is blocking and runs `mainloop()`. For app integration, run in a separate process:
 
 ```python
-overlay.hide()
+from multiprocessing import Process
+p = Process(target=overlay.start)
+p.start()
+# Later: p.terminate()
 ```
 
-**Performance:** Even faster than `show()` - typically <0.1ms.
-
 ### `stop()` Method
 
-Stop and cleanup the overlay process.
+Stop and close the overlay.
 
 ```python
 overlay.stop()
 ```
 
-**Note:** Call this when your application exits to gracefully terminate the overlay process.
+**Note:** Usually called from within the overlay process, or use `process.terminate()` from parent.
 
 ---
 
@@ -374,25 +355,12 @@ Overlay(
 
 ## ⚡ Performance
 
-### Latency Benchmarks ⭐ **UPDATED**
-
-- **activate() (duration-based):** <50ms startup
-- **start() (one-time init):** ~300ms (creates subprocess)
-- **show() / hide():** **~0.1ms** (virtually instant!)
-
-### How It Works
-
+- **Startup Latency:** <50ms
 - **Method:** Native OS window effects (no screen capture)
 - **Permissions:** None required (works without screen recording access)
 - **Memory:** Minimal footprint
-- **Process Model:** Separate process with queue-based messaging
-
-**Why so fast?** Unlike traditional screen capture approaches (400-1000ms), we use:
-1. Native OS-level window blur effects (no image processing)
-2. Persistent subprocess with `withdraw()`/`deiconify()` toggling
-3. Queue-based messaging for instant communication
 
-This makes `show()` and `hide()` nearly **10,000x faster** than recreating the overlay each time!
+**Why so fast?** Unlike traditional screen capture approaches (400-1000ms), we use native OS-level window blur effects, eliminating the need to capture, process, and re-render the screen.
 
 ---
 
@@ -452,7 +420,6 @@ Check out the [`examples/`](examples/) directory for complete working examples:
 
 - **`basic_duration.py`** - Simple blur overlay with fixed duration
 - **`black_screen.py`** - Privacy blackout screen
-- **`show_hide_control.py`** ⭐ **NEW** - Instant show/hide toggling (~0.1ms)
 - **`start_stop_control.py`** - Manual control with multiprocessing
 - **`custom_color.py`** - Custom colored overlay
 

screenoverlay-0.3.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+screenoverlay/__init__.py,sha256=3Dj4hc8poOLtYXw3boa_wl7SC5mQ31OPocfz7uOAGkE,256
+screenoverlay/overlay.py,sha256=vqf516zJKzUuslGPIhljKxSVBIIWHkVJSXMRjK4sgA0,10956
+screenoverlay-0.3.0.dist-info/licenses/LICENSE,sha256=QlEjK4tuMjNEYVlvzaIhxfsCeU8hcGZyuT85cm1YChE,1084
+screenoverlay-0.3.0.dist-info/METADATA,sha256=5A3RMRlGyi6JTGfb0fByhEv55usJp5q-6huXPf6kN5o,13861
+screenoverlay-0.3.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+screenoverlay-0.3.0.dist-info/top_level.txt,sha256=kfPL07o_kJ-mlb14Ps2zp_tIYnD8GfsSXlbDxDF6Eic,14
+screenoverlay-0.3.0.dist-info/RECORD,,

screenoverlay-0.2.1.dist-info/RECORD

@@ -1,7 +0,0 @@
-screenoverlay/__init__.py,sha256=OtIWzvmSmIj6XuMw-JzQmuYb44A_8Z4xKSUFYTa1ZqU,256
-screenoverlay/overlay.py,sha256=f5NlalqC81tm5c1g9FEfZhCqgwaJzFDvO5dNPT1uNJU,14326
-screenoverlay-0.2.1.dist-info/licenses/LICENSE,sha256=QlEjK4tuMjNEYVlvzaIhxfsCeU8hcGZyuT85cm1YChE,1084
-screenoverlay-0.2.1.dist-info/METADATA,sha256=f3AvURDIQXS_mt0H3qPjug5sf7CcM6mtxhXrgKk_lFQ,14888
-screenoverlay-0.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-screenoverlay-0.2.1.dist-info/top_level.txt,sha256=kfPL07o_kJ-mlb14Ps2zp_tIYnD8GfsSXlbDxDF6Eic,14
-screenoverlay-0.2.1.dist-info/RECORD,,