192 lines
6.9 KiB
Python
192 lines
6.9 KiB
Python
import contextlib
|
|
import gi # type: ignore
|
|
from gi.repository import Gdk, Gtk, GtkLayerShell # type: ignore
|
|
|
|
from widgets.wayland import WaylandWindow
|
|
from utils.monitors import HyprlandWithMonitors
|
|
|
|
gi.require_version("GtkLayerShell", "0.1")
|
|
|
|
|
|
class PopupWindow(WaylandWindow):
|
|
"""A simple popover window that can point to a widget."""
|
|
|
|
def __init__(
|
|
self,
|
|
parent: WaylandWindow,
|
|
pointing_to: Gtk.Widget | None = None,
|
|
margin: tuple[int, ...] | str = "0px 0px 0px 0px",
|
|
enable_boundary_checking: bool = True,
|
|
**kwargs,
|
|
):
|
|
super().__init__(**kwargs)
|
|
self.exclusivity = "none"
|
|
self._is_centered = False
|
|
self._parent = parent
|
|
self._pointing_widget = pointing_to
|
|
self._hyprland = HyprlandWithMonitors()
|
|
self._base_margin = self.extract_margin(margin)
|
|
self.margin = self._base_margin.values()
|
|
self._enable_boundary_checking = enable_boundary_checking
|
|
|
|
self.connect("notify::visible", self.do_update_handlers)
|
|
|
|
def get_coords_for_widget(self, widget: Gtk.Widget) -> tuple[int, int]:
|
|
if not ((toplevel := widget.get_toplevel()) and toplevel.is_toplevel()): # type: ignore
|
|
return 0, 0
|
|
allocation = widget.get_allocation()
|
|
x, y = widget.translate_coordinates(toplevel, allocation.x, allocation.y) or (
|
|
0,
|
|
0,
|
|
)
|
|
return round(x / 2), round(y / 2)
|
|
|
|
def set_pointing_to(self, widget: Gtk.Widget | None):
|
|
if self._pointing_widget:
|
|
with contextlib.suppress(Exception):
|
|
self._pointing_widget.disconnect_by_func(self.do_handle_size_allocate)
|
|
self._pointing_widget = widget
|
|
return self.do_update_handlers()
|
|
|
|
def do_update_handlers(self, *_):
|
|
if not self._pointing_widget:
|
|
return
|
|
|
|
if not self.get_visible():
|
|
try:
|
|
self._pointing_widget.disconnect_by_func(self.do_handle_size_allocate)
|
|
self.disconnect_by_func(self.do_handle_size_allocate)
|
|
except Exception:
|
|
pass
|
|
return
|
|
|
|
self._pointing_widget.connect("size-allocate", self.do_handle_size_allocate)
|
|
self.connect("size-allocate", self.do_handle_size_allocate)
|
|
|
|
return self.do_handle_size_allocate()
|
|
|
|
def do_handle_size_allocate(self, *_):
|
|
return self.do_reposition(self.do_calculate_edges())
|
|
|
|
def do_calculate_edges(self):
|
|
move_axe = "x"
|
|
parent_anchor = self._parent.anchor
|
|
|
|
if len(parent_anchor) != 3:
|
|
self.anchor = "left bottom"
|
|
self._is_centered = True
|
|
return move_axe
|
|
|
|
if (
|
|
GtkLayerShell.Edge.LEFT in parent_anchor
|
|
and GtkLayerShell.Edge.RIGHT in parent_anchor
|
|
):
|
|
# horizontal -> move on x-axies
|
|
move_axe = "x"
|
|
if GtkLayerShell.Edge.TOP in parent_anchor:
|
|
self.anchor = "left top"
|
|
else:
|
|
self.anchor = "left bottom"
|
|
elif (
|
|
GtkLayerShell.Edge.TOP in parent_anchor
|
|
and GtkLayerShell.Edge.BOTTOM in parent_anchor
|
|
):
|
|
# vertical -> move on y-axies
|
|
move_axe = "y"
|
|
if GtkLayerShell.Edge.RIGHT in parent_anchor:
|
|
self.anchor = "top right"
|
|
else:
|
|
self.anchor = "top left"
|
|
|
|
self._is_centered = False
|
|
return move_axe
|
|
|
|
def do_reposition(self, move_axe: str):
|
|
parent_margin = self._parent.margin
|
|
parent_x_margin, parent_y_margin = parent_margin[0], parent_margin[3]
|
|
|
|
height = self.get_allocated_height()
|
|
width = self.get_allocated_width()
|
|
|
|
# Get monitor geometry for boundary checking
|
|
current_monitor_id = self._hyprland.get_current_gdk_monitor_id()
|
|
if current_monitor_id is not None:
|
|
monitor = self._hyprland.display.get_monitor(current_monitor_id)
|
|
monitor_geometry = monitor.get_geometry()
|
|
monitor_x, monitor_y = monitor_geometry.x, monitor_geometry.y
|
|
monitor_width, monitor_height = monitor_geometry.width, monitor_geometry.height
|
|
else:
|
|
# Fallback to default screen
|
|
screen = Gdk.Screen.get_default()
|
|
monitor_x, monitor_y = 0, 0
|
|
monitor_width, monitor_height = screen.get_width(), screen.get_height()
|
|
|
|
if self._pointing_widget:
|
|
coords = self.get_coords_for_widget(self._pointing_widget)
|
|
coords_centered = (
|
|
round(coords[0] + self._pointing_widget.get_allocated_width() / 2),
|
|
round(coords[1] + self._pointing_widget.get_allocated_height() / 2),
|
|
)
|
|
else:
|
|
coords_centered = (
|
|
round(self._parent.get_allocated_width() / 2),
|
|
round(self._parent.get_allocated_height() / 2),
|
|
)
|
|
|
|
if self._is_centered:
|
|
# Calculate centered position with boundary checking
|
|
centered_x = (
|
|
(monitor_width / 2 - self._parent.get_allocated_width() / 2)
|
|
- width / 2
|
|
) + coords_centered[0]
|
|
|
|
# Apply boundary checking only if enabled
|
|
if self._enable_boundary_checking:
|
|
if centered_x < monitor_x:
|
|
centered_x = monitor_x
|
|
elif centered_x + width > monitor_x + monitor_width:
|
|
centered_x = monitor_x + monitor_width - width
|
|
|
|
self.margin = tuple(
|
|
a + b
|
|
for a, b in zip(
|
|
(0, 0, 0, centered_x),
|
|
self._base_margin.values(),
|
|
)
|
|
)
|
|
return
|
|
|
|
# Calculate position with boundary checking
|
|
if move_axe == "x":
|
|
# Horizontal positioning
|
|
calculated_x = round((parent_x_margin + coords_centered[0]) - (width / 2))
|
|
|
|
# Apply boundary checking only if enabled
|
|
if self._enable_boundary_checking:
|
|
if calculated_x < monitor_x:
|
|
calculated_x = monitor_x
|
|
elif calculated_x + width > monitor_x + monitor_width:
|
|
calculated_x = monitor_x + monitor_width - width
|
|
|
|
margin_values = (0, 0, 0, calculated_x)
|
|
else:
|
|
# Vertical positioning
|
|
calculated_y = round((parent_y_margin + coords_centered[1]) - (height / 2))
|
|
|
|
# Apply boundary checking only if enabled
|
|
if self._enable_boundary_checking:
|
|
if calculated_y < monitor_y:
|
|
calculated_y = monitor_y
|
|
elif calculated_y + height > monitor_y + monitor_height:
|
|
calculated_y = monitor_y + monitor_height - height
|
|
|
|
margin_values = (calculated_y, 0, 0, 0)
|
|
|
|
self.margin = tuple(
|
|
a + b
|
|
for a, b in zip(
|
|
margin_values,
|
|
self._base_margin.values(),
|
|
)
|
|
)
|