screenoverlay 0.3.1__py3-none-any.whl → 0.4.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.3.1'
+__version__ = '0.4.0'
 __author__ = 'Pekay'
 __all__ = ['Overlay']
 

screenoverlay/overlay.py

@@ -14,6 +14,13 @@ import time
 import atexit
 import signal
 
+# Try to import screeninfo for multi-monitor support
+try:
+    from screeninfo import get_monitors
+    HAS_SCREENINFO = True
+except ImportError:
+    HAS_SCREENINFO = False
+
 
 class NativeBlurOverlay:
     def __init__(self, mode='blur', blur_strength=3, opacity=0.85, color_tint=(136, 136, 136)):
@@ -55,6 +62,7 @@ class NativeBlurOverlay:
             self.apply_blur = True
         
         self.root = None
+        self.windows = []  # List to hold multiple windows for multi-monitor
         self._timer_id = None
         self._process = None
         self._command_queue = None
@@ -141,9 +149,12 @@ class NativeBlurOverlay:
     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
+            # 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():
@@ -151,10 +162,12 @@ class NativeBlurOverlay:
                     while not command_queue.empty():
                         cmd = command_queue.get_nowait()
                         if cmd == 'show':
-                            self.root.deiconify()
-                            self.root.lift()
+                            for win in self.windows:
+                                win.deiconify()
+                                win.lift()
                         elif cmd == 'hide':
-                            self.root.withdraw()
+                            for win in self.windows:
+                                win.withdraw()
                         elif cmd == 'stop':
                             self.root.quit()
                             return
@@ -175,6 +188,67 @@ class NativeBlurOverlay:
         finally:
             os._exit(0)
     
+    def _get_monitors(self):
+        """Get information about all monitors"""
+        if HAS_SCREENINFO:
+            try:
+                monitors = get_monitors()
+                return [(m.x, m.y, m.width, m.height) for m in monitors]
+            except:
+                pass
+        
+        # Fallback: assume single primary monitor
+        root = tk.Tk()
+        root.withdraw()
+        width = root.winfo_screenwidth()
+        height = root.winfo_screenheight()
+        root.destroy()
+        return [(0, 0, width, height)]
+    
+    def _create_windows(self):
+        """Create overlay windows for all monitors"""
+        monitors = self._get_monitors()
+        
+        # Create primary root window
+        self.root = tk.Tk()
+        self.root.overrideredirect(True)
+        self.root.attributes('-topmost', True)
+        
+        # Configure primary window for first monitor
+        if monitors:
+            x, y, width, height = monitors[0]
+            self._configure_window(self.root, x, y, width, height)
+            self.windows.append(self.root)
+        
+        # Create additional windows for other monitors
+        for x, y, width, height in monitors[1:]:
+            win = tk.Toplevel(self.root)
+            win.overrideredirect(True)
+            win.attributes('-topmost', True)
+            self._configure_window(win, x, y, width, height)
+            self.windows.append(win)
+    
+    def _configure_window(self, window, x, y, width, height):
+        """Configure a window with overlay settings"""
+        # Set background color (tint)
+        bg_color = f'#{self.color_tint[0]:02x}{self.color_tint[1]:02x}{self.color_tint[2]:02x}'
+        window.configure(bg=bg_color)
+        
+        # Set opacity
+        window.attributes('-alpha', self.opacity)
+        
+        # Position and size
+        window.geometry(f"{width}x{height}+{x}+{y}")
+        
+        # Apply native blur effect based on OS (only if mode is 'blur')
+        if self.apply_blur:
+            self._apply_native_blur_to_window(window)
+        
+        # Bind escape key to exit (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()
@@ -214,25 +288,33 @@ class NativeBlurOverlay:
         self.root.mainloop()
         
     def _apply_native_blur(self):
-        """Apply OS-native backdrop blur effect"""
+        """Apply OS-native backdrop blur effect to root window (legacy method)"""
+        self._apply_native_blur_to_window(self.root)
+    
+    def _apply_native_blur_to_window(self, window):
+        """Apply OS-native backdrop blur effect to a specific window"""
         system = platform.system()
         
         if system == 'Darwin':  # macOS
-            self._apply_macos_blur()
+            self._apply_macos_blur_to_window(window)
         elif system == 'Windows':
-            self._apply_windows_blur()
+            self._apply_windows_blur_to_window(window)
         elif system == 'Linux':
-            self._apply_linux_blur()
+            self._apply_linux_blur_to_window(window)
             
     def _apply_macos_blur(self):
-        """Apply macOS NSVisualEffectView blur"""
+        """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"""
         try:
             from Cocoa import NSView, NSVisualEffectView
             from Cocoa import NSVisualEffectBlendingModeBehindWindow, NSVisualEffectMaterialDark
             import objc
             
             # Get the Tk window's NSWindow
-            window_id = self.root.winfo_id()
+            window_id = window.winfo_id()
             
             # Create NSVisualEffectView
             # Note: This requires pyobjc-framework-Cocoa
@@ -270,7 +352,11 @@ class NativeBlurOverlay:
             print(f"macOS blur effect failed: {e}")
             
     def _apply_windows_blur(self):
-        """Apply Windows Acrylic/Blur effect"""
+        """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"""
         try:
             import ctypes
             from ctypes import wintypes
@@ -278,10 +364,10 @@ class NativeBlurOverlay:
             # Get window handle - try multiple methods
             try:
                 # Method 1: Direct window ID
-                hwnd = self.root.winfo_id()
+                hwnd = window.winfo_id()
             except:
                 # Method 2: Get parent window
-                hwnd = ctypes.windll.user32.GetParent(self.root.winfo_id())
+                hwnd = ctypes.windll.user32.GetParent(window.winfo_id())
             
             if not hwnd:
                 print("Could not get window handle for blur effect")
@@ -332,7 +418,11 @@ class NativeBlurOverlay:
             print("Overlay will work but without native blur effect")
             
     def _apply_linux_blur(self):
-        """Apply Linux compositor blur (X11/Wayland)"""
+        """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"""
         try:
             # Linux blur depends on compositor (KWin, Mutter, etc.)
             # Most compositors respect window transparency and apply blur automatically

{screenoverlay-0.3.1.dist-info → screenoverlay-0.4.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: screenoverlay
-Version: 0.3.1
+Version: 0.4.0
 Summary: Cross-platform screen overlay with blur, black, white, and custom modes
 Home-page: https://github.com/pekay-ai/screenoverlay
 Author: Pekay
@@ -25,6 +25,7 @@ Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: pyobjc-framework-Cocoa; platform_system == "Darwin"
+Requires-Dist: screeninfo
 Provides-Extra: dev
 Requires-Dist: pytest; extra == "dev"
 Requires-Dist: twine; extra == "dev"
@@ -70,6 +71,7 @@ We're releasing it as **open-source (MIT)** because we believe privacy tools sho
 
 - 🎭 **4 Overlay Modes** - blur, black, white, custom colors
 - ⚡ **Ultra Fast** - <50ms startup, native OS blur effects
+- 🖥️ **Multi-Monitor Support** - Automatically blurs ALL screens simultaneously
 - 🔒 **No Permissions** - No screen recording access required
 - 🌍 **Cross-Platform** - macOS, Windows, Linux
 - 🎯 **Simple API** - One line of code to activate
@@ -384,13 +386,15 @@ Overlay(
 
 - **Method:** Native OS window effects (no screen capture)
 - **Permissions:** None required (works without screen recording access)
-- **Memory:** Minimal footprint
+- **Memory:** Minimal footprint (~10 MB per screen)
 - **Process Model:** Separate process with queue-based messaging
+- **Multi-Monitor:** Automatically detects and covers all screens
 
 **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
+4. One window per monitor (all controlled simultaneously)
 
 This makes `show()` and `hide()` nearly **10,000x faster** than recreating the overlay each time!
 

screenoverlay-0.4.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+screenoverlay/__init__.py,sha256=NX7qDYscRGygfi9p6HJC_gT876L8wNpX1f01sS1mxPc,256
+screenoverlay/overlay.py,sha256=h3z8tl33oB-i4q91Zoc7-mqjypnbYOtZNi5fQKmeoI8,17843
+screenoverlay-0.4.0.dist-info/licenses/LICENSE,sha256=QlEjK4tuMjNEYVlvzaIhxfsCeU8hcGZyuT85cm1YChE,1084
+screenoverlay-0.4.0.dist-info/METADATA,sha256=6XJrI12_VPcULWDkiq69itu6THJW9dhCXD3jAEz63v4,15143
+screenoverlay-0.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+screenoverlay-0.4.0.dist-info/top_level.txt,sha256=kfPL07o_kJ-mlb14Ps2zp_tIYnD8GfsSXlbDxDF6Eic,14
+screenoverlay-0.4.0.dist-info/RECORD,,

screenoverlay-0.3.1.dist-info/RECORD

@@ -1,7 +0,0 @@
-screenoverlay/__init__.py,sha256=29uNmyZ483sH3HLk6u-yJ4v5beNOEjbvd5s7SRtKsE0,256
-screenoverlay/overlay.py,sha256=f5NlalqC81tm5c1g9FEfZhCqgwaJzFDvO5dNPT1uNJU,14326
-screenoverlay-0.3.1.dist-info/licenses/LICENSE,sha256=QlEjK4tuMjNEYVlvzaIhxfsCeU8hcGZyuT85cm1YChE,1084
-screenoverlay-0.3.1.dist-info/METADATA,sha256=Kxip-tXj48r2tN_Ihu5gLMrbU9P6ULX7PQZQYvB8diw,14888
-screenoverlay-0.3.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-screenoverlay-0.3.1.dist-info/top_level.txt,sha256=kfPL07o_kJ-mlb14Ps2zp_tIYnD8GfsSXlbDxDF6Eic,14
-screenoverlay-0.3.1.dist-info/RECORD,,