multi-monitor

Author: Axenide

modules/overview.py

@@ -27,7 +27,7 @@
 
 icon_resolver = IconResolver()
 connection = Hyprland()
-SCALE = 0.1
+BASE_SCALE = 0.1  # Base scale factor for overview
 
 # Credit to Aylur for the drag and drop code
 TARGET = [Gtk.TargetEntry.new("text/plain", Gtk.TargetFlags.SAME_APP, 0)]
@@ -175,18 +175,22 @@ def on_button_click(self, *_):
 
 
 class WorkspaceEventBox(EventBox):
-    def __init__(self, workspace_id: int, fixed: Gtk.Fixed | None = None, monitor_width: int = None, monitor_height: int = None):
+    def __init__(self, workspace_id: int, fixed: Gtk.Fixed | None = None, monitor_width: int = None, monitor_height: int = None, monitor_scale: float = 1.0):
         self.fixed = fixed
 
         # Use provided monitor dimensions or fallback to current screen
         width = monitor_width or CURRENT_WIDTH
         height = monitor_height or CURRENT_HEIGHT
 
+        # Workspace containers should maintain consistent size across monitors
+        # Only use BASE_SCALE, don't multiply by monitor_scale for the container
+        container_scale = BASE_SCALE
+        
         super().__init__(
             name="overview-workspace-bg",
             h_expand=True,
             v_expand=True,
-            size=(int(width * SCALE), int(height * SCALE)),
+            size=(int(width * container_scale), int(height * container_scale)),
             child=fixed
             if fixed
             else Label(
@@ -365,15 +369,21 @@ def update(self, signal_update=False):
 
         self.children = [Box(spacing=8) for _ in range(rows)]
 
-        # Get monitor dimensions for scaling
+        # Get monitor dimensions and scale for scaling
         monitor_width = CURRENT_WIDTH
         monitor_height = CURRENT_HEIGHT
+        monitor_scale = 1.0
 
         if self.monitor_manager:
             monitor_info = self.monitor_manager.get_monitor_by_id(self.monitor_id)
             if monitor_info:
                 monitor_width = monitor_info['width']
                 monitor_height = monitor_info['height']
+                monitor_scale = monitor_info.get('scale', 1.0)
+        
+        # Calculate effective scale for this monitor
+        # Higher scale monitors need larger overview elements to appear the same physical size
+        effective_scale = BASE_SCALE * monitor_scale
 
         monitors = {
             monitor["id"]: (monitor["x"], monitor["y"], monitor["transform"])
@@ -389,7 +399,7 @@ def update(self, signal_update=False):
                     title=client["title"],
                     address=client["address"],
                     app_id=client["initialClass"],
-                    size=(client["size"][0] * SCALE, client["size"][1] * SCALE),
+                    size=(client["size"][0] * effective_scale, client["size"][1] * effective_scale),
                     transform=monitors[client["monitor"]][2],
                 )
                 self.clients[client["address"]] = btn
@@ -398,8 +408,8 @@ def update(self, signal_update=False):
                     self.workspace_boxes[w_id] = Gtk.Fixed.new()
                 self.workspace_boxes[w_id].put(
                     btn,
-                    abs(client["at"][0] - monitors[client["monitor"]][0]) * SCALE,
-                    abs(client["at"][1] - monitors[client["monitor"]][1]) * SCALE,
+                    abs(client["at"][0] - monitors[client["monitor"]][0]) * effective_scale,
+                    abs(client["at"][1] - monitors[client["monitor"]][1]) * effective_scale,
                 )
 
         # Generate workspaces only for this monitor's range
@@ -420,7 +430,8 @@ def update(self, signal_update=False):
                             w_id,
                             self.workspace_boxes.get(w_id),
                             monitor_width=monitor_width,
-                            monitor_height=monitor_height
+                            monitor_height=monitor_height,
+                            monitor_scale=monitor_scale
                         ),
                     ],
                 )

services/monitor_focus.py

@@ -44,6 +44,7 @@ def __init__(self):
 
         self._initialized = True
         self._monitor_name_to_id = {}
+        self._monitor_info = {}  # Store rich monitor information
         self._current_workspace = 1
         self._current_monitor_name = ""
         self._listening = False
@@ -57,19 +58,32 @@ def __init__(self):
         self.start_listening()
 
     def _update_monitor_mapping(self):
-        """Update the monitor name to ID mapping."""
+        """Update the monitor name to ID mapping with rich monitor information."""
         try:
             # Import here to avoid circular imports
             from utils.monitor_manager import get_monitor_manager
             manager = get_monitor_manager()
             monitors = manager.get_monitors()
 
             self._monitor_name_to_id = {}
+            self._monitor_info = {}  # Store rich monitor information
             for monitor in monitors:
-                self._monitor_name_to_id[monitor['name']] = monitor['id']
+                monitor_name = monitor['name']
+                monitor_id = monitor['id']
+                self._monitor_name_to_id[monitor_name] = monitor_id
+                self._monitor_info[monitor_id] = {
+                    'name': monitor_name,
+                    'width': monitor.get('width', 1920),
+                    'height': monitor.get('height', 1080),
+                    'x': monitor.get('x', 0),
+                    'y': monitor.get('y', 0),
+                    'scale': monitor.get('scale', 1.0),
+                    'focused': monitor.get('focused', False)
+                }
         except ImportError:
             # Fallback if monitor manager not available yet
             self._monitor_name_to_id = {}
+            self._monitor_info = {}
 
     def start_listening(self):
         """Start listening to Hyprland events in a separate thread."""
@@ -188,6 +202,24 @@ def get_current_workspace(self) -> int:
     def get_monitor_id_by_name(self, monitor_name: str) -> Optional[int]:
         """Get monitor ID by name."""
         return self._monitor_name_to_id.get(monitor_name)
+    
+    def get_monitor_info(self, monitor_id: int) -> Optional[dict]:
+        """Get rich monitor information by ID."""
+        return self._monitor_info.get(monitor_id)
+    
+    def get_current_monitor_info(self) -> Optional[dict]:
+        """Get rich information for current monitor."""
+        current_id = self.get_current_monitor_id()
+        return self.get_monitor_info(current_id)
+    
+    def get_monitor_scale(self, monitor_id: int) -> float:
+        """Get monitor scale factor by ID."""
+        info = self.get_monitor_info(monitor_id)
+        return info.get('scale', 1.0) if info else 1.0
+    
+    def get_current_monitor_scale(self) -> float:
+        """Get current monitor scale factor."""
+        return self.get_monitor_scale(self.get_current_monitor_id())
 
 
 # Singleton accessor

utils/monitor_manager.py

@@ -65,17 +65,45 @@ def set_monitor_focus_service(self, service):
         if service:
             service.monitor_focused.connect(self._on_monitor_focused)
 
+    def _get_gtk_monitor_info(self) -> List[Dict]:
+        """Get monitor information using GTK/GDK including scale factors."""
+        gtk_monitors = []
+        try:
+            display = Gdk.Display.get_default()
+            if display and hasattr(display, 'get_n_monitors'):
+                n_monitors = display.get_n_monitors()
+                for i in range(n_monitors):
+                    monitor = display.get_monitor(i)
+                    if monitor:
+                        geometry = monitor.get_geometry()
+                        scale_factor = monitor.get_scale_factor()
+                        model = monitor.get_model() or f'monitor-{i}'
+                        
+                        gtk_monitors.append({
+                            'id': i,
+                            'name': model,
+                            'width': geometry.width,
+                            'height': geometry.height,
+                            'x': geometry.x,
+                            'y': geometry.y,
+                            'scale': scale_factor
+                        })
+        except Exception as e:
+            print(f"Error getting GTK monitor info: {e}")
+        
+        return gtk_monitors
+
     def refresh_monitors(self) -> List[Dict]:
         """
-        Detect monitors using Hyprland API with GTK fallback.
+        Detect monitors using Hyprland API for accurate info, with GTK for scale detection.
         
         Returns:
-            List of monitor dictionaries with id, name, width, height, x, y
+            List of monitor dictionaries with id, name, width, height, x, y, scale
         """
         self._monitors = []
 
         try:
-            # Try Hyprland first
+            # Try Hyprland first for primary info (more accurate)
             result = subprocess.run(
                 ["hyprctl", "monitors", "-j"],
                 capture_output=True,
@@ -85,14 +113,20 @@ def refresh_monitors(self) -> List[Dict]:
             hypr_monitors = json.loads(result.stdout)
 
             for i, monitor in enumerate(hypr_monitors):
+                monitor_name = monitor.get('name', f'monitor-{i}')
+                
+                # Get scale directly from Hyprland (more reliable)
+                hypr_scale = monitor.get('scale', 1.0)
+                
                 self._monitors.append({
                     'id': i,
-                    'name': monitor.get('name', f'monitor-{i}'),
+                    'name': monitor_name,
                     'width': monitor.get('width', 1920),
                     'height': monitor.get('height', 1080),
                     'x': monitor.get('x', 0),
                     'y': monitor.get('y', 0),
-                    'focused': monitor.get('focused', False)
+                    'focused': monitor.get('focused', False),
+                    'scale': hypr_scale
                 })
 
                 # Initialize states for new monitors
@@ -101,7 +135,7 @@ def refresh_monitors(self) -> List[Dict]:
                     self._current_notch_module[i] = None
 
         except (subprocess.CalledProcessError, json.JSONDecodeError, FileNotFoundError):
-            # Fallback to GTK
+            # Fallback to GTK only if Hyprland fails
             self._fallback_to_gtk()
 
         # Ensure we have at least one monitor
@@ -113,7 +147,8 @@ def refresh_monitors(self) -> List[Dict]:
                 'height': 1080,
                 'x': 0,
                 'y': 0,
-                'focused': True
+                'focused': True,
+                'scale': 1.0
             }]
             self._notch_states[0] = False
             self._current_notch_module[0] = None
@@ -128,14 +163,15 @@ def refresh_monitors(self) -> List[Dict]:
         return self._monitors
 
     def _fallback_to_gtk(self):
-        """Fallback monitor detection using GTK."""
+        """Fallback monitor detection using GTK with scale information."""
         try:
             display = Gdk.Display.get_default()
             if display and hasattr(display, 'get_n_monitors'):
                 n_monitors = display.get_n_monitors()
                 for i in range(n_monitors):
                     monitor = display.get_monitor(i)
                     geometry = monitor.get_geometry()
+                    scale_factor = monitor.get_scale_factor()
 
                     self._monitors.append({
                         'id': i,
@@ -144,7 +180,8 @@ def _fallback_to_gtk(self):
                         'height': geometry.height,
                         'x': geometry.x,
                         'y': geometry.y,
-                        'focused': i == 0  # Assume first monitor is focused
+                        'focused': i == 0,  # Assume first monitor is focused
+                        'scale': scale_factor
                     })
 
                     if i not in self._notch_states:
@@ -200,6 +237,19 @@ def get_monitor_for_workspace(self, workspace_id: int) -> int:
             return 0
         return (workspace_id - 1) // 10
 
+    def get_monitor_scale(self, monitor_id: int) -> float:
+        """
+        Get scale factor for a monitor.
+        
+        Args:
+            monitor_id: Monitor ID
+            
+        Returns:
+            Scale factor (default 1.0 if not found)
+        """
+        monitor = self.get_monitor_by_id(monitor_id)
+        return monitor.get('scale', 1.0) if monitor else 1.0
+    
     def is_notch_open(self, monitor_id: int) -> bool:
         """Check if notch is open on a monitor."""
         return self._notch_states.get(monitor_id, False)

version.json

@@ -1,7 +1,7 @@
 {
-	"version": "0.0.38", 
+	"version": "0.0.40", 
   "pkg_update": false,
 	"changelog": [
-    "<b>tweak:</b> General optimizations and bug fixes." 
+    "<b>feat:</b> Multi-monitor support"
   ]
 }