One keyboard and mouse for a Mac and a Windows PC over the local network, in either direction.
"""The Crossing page's two pictures: the arrangement diagram at the top of Ways in, and the push
strip in Resistance. Geometry is pages_win's, pure and tested; this file only paints it."""
from __future__ import annotations
from core.i18n import N_, tr, trc
import sys
from PySide6.QtCore import QPointF, QRectF, QSize, Qt, QTimer
from PySide6.QtGui import QColor, QFontMetrics, QPainter, QPainterPath, QPen, QAccessible, QAccessibleAnnouncementEvent
from PySide6.QtWidgets import QLineEdit, QPushButton, QSlider, QSizePolicy, QToolTip, QWidget
import motion
import pages_win
import theme
import tokens
from core import ways
from core.identify_screens import display_numbers
from core.resistance_strip import MAX_RESISTANCE, resistance_x
OTHER = N_("Other machine")
DASHBOARD_NAME = N_("This PC")
DIRECTION_NAMES = {"left": N_("left"), "right": N_("right"), "top": N_("top"), "bottom": N_("bottom")}
ATLAS_TILE = (160, 100)
SCREEN = (120.0, 75.0)
GAP = 14.0
PAD = 8.0
CAP_ROW = 34.0
NOTE_ROW = 22.0
LIT = 3.0
CORNER = 16.0
# The marks of the machines the page is not showing: there, but not the ones being edited.
QUIET = "ink_3"
QUIET_ALPHA = 0.55
# The clear space centred on each third boundary of the selected machine's seam and tracks.
THIRD_GAP = 2.0
CYCLE_BOX = 16.0
RESIZE_GRIP = 16.0
RESIZE_HELP = N_("Tile size can be changed by dragging a corner or pressing Alt+arrow.")
def _colour(name: str, alpha: float = 1.0) -> QColor:
colour = QColor(theme.colour(name))
colour.setAlphaF(max(0.0, min(1.0, alpha)))
return colour
def _lit(lead: float, level: float) -> QColor:
"""A mark on this PC's screen: the signal colour for the machine shown, quieter for the rest."""
lead = max(0.0, min(1.0, lead))
return _blend(QUIET, "signal", lead, level * (QUIET_ALPHA + (1.0 - QUIET_ALPHA) * lead))
def _blend(quiet: str, strong: str, level: float, alpha: float = 1.0) -> QColor:
"""`quiet` at 0, `strong` at 1, so a machine chosen or left eases between the two."""
one, two = QColor(theme.colour(quiet)), QColor(theme.colour(strong))
level = max(0.0, min(1.0, level))
mixed = QColor.fromRgbF(*(a + (b - a) * level for a, b in zip(one.getRgbF()[:3], two.getRgbF()[:3])))
mixed.setAlphaF(max(0.0, min(1.0, alpha)))
return mixed
def _drawn_side(machine: dict, alone: bool) -> str:
# One machine with no side is drawn on the right, as the one-machine page always drew it.
return machine.get("side") or ("right" if alone else "")
def _marks(machines, shortcut) -> dict:
"""Each mark the diagram can draw, keyed (kind, machine, detail), at 1 when the settings light it;
("lead", machine) at 1 lights its marks in the signal colour, ("named", machine) its name in ink."""
alone = len(machines) == 1
marks = {("cap",): 1.0 if shortcut else 0.0}
for machine in machines:
key, methods = machine["key"], set(machine["methods"])
edge = _drawn_side(machine, alone) if machine.get("side") else ""
for side in pages_win.SIDE_ANGLE:
marks[("edge", key, side)] = 1.0 if "edge" in methods and side == edge else 0.0
marks[("track", key, side)] = 1.0 if "part" in methods and side == edge else 0.0
for part in pages_win.PART_SPANS:
lit = "part" in methods and side == edge and part in machine["parts"]
marks[("part", key, side, part)] = 1.0 if lit else 0.0
for name in pages_win.CORNER_NAMES:
marks[("corner", key, name)] = 1.0 if "corner" in methods and name == machine["corner"] else 0.0
marks[("lead", key)] = 1.0 if machine["chosen"] or alone else 0.0
marks[("named", key)] = 1.0 if machine["chosen"] and not alone else 0.0
return marks
class ArrangementDiagram(QWidget):
"""This PC's screen in the middle and each paired machine's beside the side it is on, two on one
side sharing it; on this PC's screen, lit, whatever crosses to each, the chosen machine's in the
signal colour and the rest quieter; the machines with no side named underneath; the shortcut as a
key cap below that."""
def __init__(self, parent: QWidget | None = None) -> None:
super().__init__(parent)
self.setAccessibleName(tr("Arrangement"))
policy = QSizePolicy(QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Preferred)
policy.setHeightForWidth(True)
self.setSizePolicy(policy)
self._state = None
self._machines: list = []
# Where each machine's screen is drawn now, by key: [angle, start, end, shown], moving between states.
self._places: dict = {}
self._labels: dict = {}
self._marks = _marks([], False)
self._unplaced = ""
self._cap_text = ""
def sizeHint(self) -> QSize:
return QSize(2 * round(SCREEN[0]) + round(GAP) + 2 * round(PAD), self._height())
def minimumSizeHint(self) -> QSize:
return QSize(2 * round(SCREEN[0]) + round(GAP), self._height())
def _drawing(self, width: float):
keys = [key for key, place in self._places.items() if place[3] > 0.001]
placed = [tuple(self._places[key][:3]) for key in keys]
available = max(1.0, width - 2 * PAD)
centre_pc = len(self._machines) > 1
pc, rects, _height = pages_win.layout_rects(available, PAD, placed, SCREEN, GAP,
centre_pc=centre_pc)
bounds_left = min([pc[0], *(rect[0] for rect in rects)])
bounds_right = max([pc[0] + pc[2], *(rect[0] + rect[2] for rect in rects)])
scale = available * 0.9 / max(1.0, bounds_right - bounds_left)
screen = (SCREEN[0] * scale, SCREEN[1] * scale)
gap = GAP * scale
pc, rects, height = pages_win.layout_rects(available, PAD, placed, screen, gap,
centre_pc=centre_pc)
metrics = QFontMetrics(theme.font(tokens.TYPE["small"], 600))
needed = max((metrics.boundingRect(QRectF(0, 0, max(1, rect[2] - 8), 10000).toRect(),
int(Qt.TextFlag.TextWrapAnywhere), name).height() + 4
for rect, name in [(pc, tr(DASHBOARD_NAME)), *[(rect, self._labels.get(key, tr(OTHER)))
for key, rect in zip(keys, rects)]]), default=screen[1])
if needed > min([pc[3], *(rect[3] for rect in rects)]):
screen = (screen[0], screen[1] * needed / max(1, min([pc[3], *(rect[3] for rect in rects)])))
pc, rects, height = pages_win.layout_rects(available, PAD, placed, screen, gap,
centre_pc=centre_pc)
return (pc[0] + PAD, pc[1], pc[2], pc[3]), {key: (rect[0] + PAD, *rect[1:]) for key, rect in zip(keys, rects)}, height
def _height(self, width: int | None = None) -> int:
_pc, _rects, height = self._drawing(float(width if width is not None else self.width() or 2 * SCREEN[0] + GAP + 2 * PAD))
return round(PAD + height + PAD + (NOTE_ROW if self._unplaced else 0.0) + CAP_ROW * self._marks[("cap",)])
def heightForWidth(self, width: int) -> int:
return self._height(width)
def set_machines(self, machines, key_name, style, shortcut) -> None:
"""Each machine a dict: `key`, `label` ("" for the placeholder of an unpaired PC), `side` (""
when not placed), `methods`, `parts`, `corner` and `chosen`."""
machines = [dict(machine, methods=list(machine["methods"]), parts=list(machine["parts"])) for machine in machines]
state = (repr(machines), key_name, style, shortcut)
if state == self._state:
return
first = self._state is None
self._state = state
self._machines = machines
alone = len(machines) == 1
self._labels = {machine["key"]: machine["label"] or tr(OTHER) for machine in machines}
if shortcut:
self._cap_text = pages_win.trigger_phrase(key_name, style)
self._unplaced = "" if alone else pages_win.unplaced_line(
[machine["label"] for machine in machines if not machine.get("side")])
self.setAccessibleDescription(pages_win.diagram_description(
[dict(machine, label=self._labels[machine["key"]]) for machine in machines],
key_name, style, shortcut))
targets = _marks(machines, shortcut)
slots = pages_win.side_slots([dict(machine, side=_drawn_side(machine, alone)) for machine in machines])
ends = {}
for machine, slot in zip(machines, slots):
held = self._places.get(machine["key"])
if slot is None:
ends[machine["key"]] = list(held[:3]) + [0.0] if held else [0.0, 0.0, 1.0, 0.0]
continue
side, start, end = slot
# A machine already drawn goes round to its new side; one just placed fades in there.
drawn = held is not None and held[3] > 0.0 and not first
angle = pages_win.turn_to(held[0], side) if drawn else pages_win.SIDE_ANGLE[side]
ends[machine["key"]] = [angle, start, end, 1.0]
for key, held in self._places.items():
# A machine removed or no longer placed fades where it was.
ends.setdefault(key, list(held[:3]) + [0.0])
starts = {}
for key, end in ends.items():
held = self._places.get(key)
starts[key] = list(held) if held is not None and held[3] > 0.0 else end[:3] + [0.0]
start_marks = dict(self._marks)
def apply(t):
self._places = {key: [a + (b - a) * t for a, b in zip(starts[key], end)] for key, end in ends.items()}
self._marks = {key: start_marks.get(key, 0.0) + (targets.get(key, 0.0) - start_marks.get(key, 0.0)) * t
for key in set(targets) | set(start_marks)}
self.updateGeometry()
self.update()
def settle():
self._places = {key: [end[0] % 360.0, end[1], end[2], end[3]] for key, end in ends.items() if end[3] > 0.0
or key in self._labels}
self._marks = {key: level for key, level in targets.items()}
self.updateGeometry()
self.update()
if first:
apply(1.0)
settle()
return
motion.animate(self, "arrangement", 0.0, 1.0, apply, settle)
def paintEvent(self, _event) -> None:
painter = QPainter(self)
painter.setRenderHint(QPainter.RenderHint.Antialiasing)
pc, rects, height = self._drawing(float(self.width()))
radius = tokens.RADIUS["field"]
for key, rect in rects.items():
painter.setOpacity(self._places[key][3])
named = self._marks.get(("named", key), 0.0)
self._screen(painter, QRectF(*rect), self._labels.get(key, tr(OTHER)), "panel", _blend("edge", "ink_3", named),
_blend("ink_3", "ink", named), radius)
painter.setOpacity(1.0)
self._screen(painter, QRectF(*pc), tr(DASHBOARD_NAME), "well", _colour("edge"), _colour("ink_2"), radius)
# The machines not shown first, so the chosen one's marks lie over theirs where they meet.
for key, level in sorted(self._marks.items(), key=lambda item: self._marks.get(("lead", item[0][1]), 0.0)
if len(item[0]) > 1 else 0.0):
if level <= 0.001 or key[0] in ("cap", "lead", "named"):
continue
kind, lead = key[0], self._marks.get(("lead", key[1]), 0.0)
if kind == "edge":
self._segment(painter, pc, key[2], 0.0, 1.0, level, lead, LIT)
elif kind == "track":
self._track(painter, pc, key[2], level)
elif kind == "part":
start, end = pages_win.PART_SPANS[key[3]]
self._segment(painter, pc, key[2], start, end, level, lead, LIT, gap=2.0)
elif kind == "corner":
self._corner(painter, pc, key[2], level, lead)
top = PAD + height + PAD
if self._unplaced:
painter.setPen(_colour("ink_3"))
painter.setFont(theme.font(tokens.TYPE["note"]))
line = QRectF(PAD, top, self.width() - 2 * PAD, NOTE_ROW)
painter.drawText(line, Qt.AlignmentFlag.AlignHCenter | Qt.AlignmentFlag.AlignTop,
painter.fontMetrics().elidedText(self._unplaced, Qt.TextElideMode.ElideRight, int(line.width())))
top += NOTE_ROW
level = self._marks[("cap",)]
if level > 0.001 and self._cap_text:
self._cap(painter, top, level)
painter.end()
def _screen(self, painter, rect: QRectF, name, fill, line: QColor, ink: QColor, radius) -> None:
painter.setPen(QPen(line, 1.0))
painter.setBrush(_colour(fill))
painter.drawRoundedRect(rect.adjusted(0.5, 0.5, -0.5, -0.5), radius, radius)
painter.setPen(ink)
painter.setFont(theme.font(tokens.TYPE["small"], 600))
metrics = painter.fontMetrics()
room = rect.adjusted(4, 2, -4, -2)
wrapped = Qt.AlignmentFlag.AlignCenter | Qt.TextFlag.TextWrapAnywhere
painter.drawText(room, wrapped, name)
@staticmethod
def _segment(painter, rect, side, start, end, level, lead, width, gap=0.0) -> None:
# Grows from its middle as it comes in.
middle = (start + end) / 2.0
half = (end - start) / 2.0 * level
x1, y1, x2, y2 = pages_win.side_segment(rect, side, middle - half, middle + half, inset=width / 2.0 + 1.0)
if gap and level > 0:
if x1 == x2:
y1, y2 = y1 + gap, y2 - gap
else:
x1, x2 = x1 + gap, x2 - gap
pen = QPen(_lit(lead, level), width)
pen.setCapStyle(Qt.PenCapStyle.RoundCap)
painter.setPen(pen)
painter.drawLine(QPointF(x1, y1), QPointF(x2, y2))
def _track(self, painter, rect, side, level) -> None:
"""Part of the edge: the whole side as a dim track, with a divider between the thirds."""
pen = QPen(_colour("off", level), LIT)
pen.setCapStyle(Qt.PenCapStyle.RoundCap)
painter.setPen(pen)
x1, y1, x2, y2 = pages_win.side_segment(rect, side, 0.5 - 0.5 * level, 0.5 + 0.5 * level, inset=LIT / 2.0 + 1.0)
painter.drawLine(QPointF(x1, y1), QPointF(x2, y2))
pen = QPen(_colour("edge", level), 1.0)
painter.setPen(pen)
for fraction in (1.0 / 3.0, 2.0 / 3.0):
x1, y1, _x2, _y2 = pages_win.side_segment(rect, side, fraction, fraction, inset=LIT / 2.0 + 1.0)
if side in ("left", "right"):
painter.drawLine(QPointF(x1 - 5, y1), QPointF(x1 + 5, y1))
else:
painter.drawLine(QPointF(x1, y1 - 5), QPointF(x1, y1 + 5))
@staticmethod
def _corner(painter, rect, corner, level, lead) -> None:
size = CORNER * (0.4 + 0.6 * level)
x, y, w, h = pages_win.corner_box(rect, corner, size)
box = QRectF(x, y, w, h).adjusted(2, 2, -2, -2)
painter.setPen(QPen(_lit(lead, level), 1.5))
painter.setBrush(_lit(lead, 0.35 * level))
painter.drawRoundedRect(box, 2, 2)
def _cap(self, painter, top, level) -> None:
key, _sep, how = self._cap_text.partition(", ")
face = theme.mono_font(tokens.TYPE["small"], 700)
painter.setFont(face)
metrics = painter.fontMetrics()
key_w = metrics.horizontalAdvance(key) + 18
rest = f", {how}"
body = theme.font(tokens.TYPE["note"])
painter.setFont(body)
rest_w = painter.fontMetrics().horizontalAdvance(rest)
total = key_w + 2 + rest_w
left = (self.width() - total) / 2.0
cap = QRectF(left, top + 2 + (1.0 - level) * 6.0, key_w, 24)
painter.setOpacity(level)
painter.setPen(QPen(_colour("edge"), 1.0))
painter.setBrush(_colour("ground"))
painter.drawRoundedRect(cap.adjusted(0.5, 0.5, -0.5, -0.5), tokens.RADIUS["keycap"], tokens.RADIUS["keycap"])
painter.setPen(QPen(_colour("edge"), 2.0))
painter.drawLine(QPointF(cap.left() + 3, cap.bottom() - 1), QPointF(cap.right() - 3, cap.bottom() - 1))
painter.setPen(_colour("signal"))
painter.setFont(face)
painter.drawText(cap.adjusted(0, 0, 0, -2), Qt.AlignmentFlag.AlignCenter, key)
painter.setPen(_colour("ink_2"))
painter.setFont(body)
painter.drawText(QRectF(cap.right() + 2, cap.top(), rest_w + 4, cap.height()),
Qt.AlignmentFlag.AlignVCenter | Qt.AlignmentFlag.AlignLeft, rest)
painter.setOpacity(1.0)
def outcome_for_tile(state, crosses, is_own=False, other_name=""):
if is_own:
return ""
if state in ("between", "set-elsewhere", "set_elsewhere") and other_name:
return f"Crosses to {other_name}" if state == "between" else f"Set on {other_name}"
if state in ("between", "set-elsewhere", "set_elsewhere"):
return "Set elsewhere"
if state == "gap" or not crosses:
return "Drag to connect" if state == "gap" else "Edge off"
return "Crosses"
class AtlasCanvas(QWidget):
"""One tile per paired machine, laid out around this screen with shared edge snaps."""
def __init__(self, parent=None, on_drop=None, on_rename=None, on_leave_out=None, on_cycle=None,
on_select=None, on_third=None, on_edit_machine=None):
super().__init__(parent)
self.on_drop = on_drop or (lambda *_: None)
self.on_rename = on_rename or (lambda *_: None)
self.on_leave_out = on_leave_out or (lambda *_: None)
self.on_cycle = on_cycle or (lambda *_: None)
self.on_select = on_select or (lambda *_: None)
self.on_third = on_third or (lambda *_: None)
self.on_edit_machine = on_edit_machine or (lambda *_: None)
self.profile_mode = False
self.remote = False
self.read_only = False
self._profile_press = None
self._profile_press_point = None
self.on_announce = None
self.on_hint = None
self.on_rename_state = None
self.setMinimumHeight(268)
self.setMaximumHeight(268)
self.setFocusPolicy(Qt.FocusPolicy.StrongFocus)
self.setMouseTracking(True)
self.setAccessibleName(tr("Crossing layout"))
self.setToolTip("")
self.tiles = {}
self.labels = {}
self.states = {}
self.selected = None
self.own_id = None
self.shelf_ids = set()
self.left_out_ids = set()
self.in_use = {}
self.cycle = {}
self.cycle_mode = "last"
self.capable = set()
self._drag = None
self._resizing = False
self._drag_display = None
self._display_offset_start = None
self._dragged_display = False
self._split_on_release = False
self._group_on_release = False
self._keyboard_focus = False
self._hover = None
self._third_press = None
self.corner_marks = []
self.wrap_marks = []
self.wrap_label_rects = []
self.seam_paths = []
self.ledger_height = False
self._height_timer = QTimer(self)
self._height_timer.setSingleShot(True)
self._height_timer.timeout.connect(self._fit_ledger_height)
self._origin = None
self._scale = 1.0
self._bounds = (0, 0, 1, 1)
self._recentre_colours = None
self.recentre_button = QPushButton(tr("Recentre"), self)
self.recentre_button.setFont(theme.font(tokens.TYPE["note"]))
self.recentre_button.setFixedSize(76, 26)
self.recentre_button.clicked.connect(self.recentre)
self.recentre_button.setVisible(False)
self.recentre_button.installEventFilter(self)
self.rename_edit = QLineEdit(self)
self.rename_edit.setFont(theme.font(tokens.TYPE["body"]))
self.rename_edit.setFixedHeight(28)
self.rename_edit.setStyleSheet("QLineEdit { border-radius: 4px; padding: 3px 6px; }")
self._rename_peer = None
self.rename_edit.setVisible(False)
self.rename_edit.returnPressed.connect(self._save_rename)
self.rename_edit.installEventFilter(self)
def set_tiles(self, tiles, labels, states, selected, cycle_mode="last", cycle=None, capable=(), own_id=None,
rename_values=None):
seen = (tiles, labels, states, selected, cycle_mode, cycle, tuple(sorted(capable or ())), own_id,
rename_values, self.profile_mode, self.remote, self.read_only)
if seen == getattr(self, "_tiles_seen", None):
return
self._tiles_seen = seen
self.tiles = {key: dict(tile) for key, tile in tiles.items()}
self.labels = dict(labels)
self.rename_values = dict(rename_values if rename_values is not None else labels)
self.states = {key: dict(state) for key, state in states.items()}
self.selected = selected if selected in tiles else next(iter(tiles), None)
self.cycle_mode = cycle_mode
self.cycle = dict(cycle or {})
self.capable = set(capable)
self.own_id = own_id
if (self.remote or self.read_only) and self._rename_peer is not None:
self._rename_peer = None
self.rename_edit.hide()
if self.on_rename_state:
self.on_rename_state(False)
if own_id in self.tiles and not self.remote:
own_detail = self.states.get(own_id, {}).get("detail") or \
("Linux" if sys.platform.startswith("linux") else "Windows")
self.states.setdefault(own_id, {}).update(
detail=own_detail, linked=True
)
description = [self.labels.get(peer, OTHER) for peer in self.tiles]
own_detail = self.states.get(own_id, {}).get("detail", "")
if own_id in self.tiles and own_detail:
description.append(own_detail)
if not self.read_only and any(peer not in self.shelf_ids for peer in self.tiles):
description.append(tr(RESIZE_HELP))
self.setAccessibleDescription(trc("list", "; ").join(description))
self._geometry()
if self._drag is None:
self.update()
def set_left_out(self, peers, in_use=None, dormant=()):
seen = (set(peers), in_use, set(dormant))
if seen == getattr(self, "_left_out_seen", None):
return
self._left_out_seen = seen
self.left_out_ids = set(peers)
self.in_use = dict(in_use or {})
self.shelf_ids = self.left_out_ids | set(dormant) | {peer for peer, enabled in self.in_use.items() if enabled is False}
self._geometry()
self.update()
def set_cycle(self, peer, enabled):
if self.remote or self.read_only:
return
self.cycle[peer] = bool(enabled)
self.on_cycle(peer, bool(enabled))
self.update()
def put_back(self, peer):
if not self.remote and not self.read_only:
self.on_leave_out(peer, False)
def leave_out(self, peer):
if not self.remote and not self.read_only:
self.on_leave_out(peer, True)
def animate_tile(self, peer, target, done=None):
current = self.tiles[peer]
start = (current["x"], current["y"])
end = (target["x"], target["y"])
def apply(position):
self.tiles[peer] = {**current, "x": round(position[0]), "y": round(position[1])}
self._geometry()
self.update()
motion.animate(self, f"tile:{peer}", start, end, apply, done=done)
def tile_rect(self, peer):
tile = self.tiles[peer]
x, y, w, h = (tile[k] for k in ("x", "y", "w", "h"))
left, top, _width, _height = self._bounds
return QRectF((x-left)*self._scale + self._origin.x(), (y-top)*self._scale + self._origin.y(),
w*self._scale, h*self._scale)
def display_rect(self, peer, display):
frame = next(frame for frame in ways._display_frames(self.tiles[peer]) if frame["display"] == display)
left, top, _width, _height = self._bounds
return QRectF((frame["x"]-left)*self._scale + self._origin.x(),
(frame["y"]-top)*self._scale + self._origin.y(),
frame["w"]*self._scale, frame["h"]*self._scale)
def display_at(self, point):
for peer in reversed(list(self.tiles)):
if peer in self.shelf_ids or not self.tiles[peer].get("displays"):
continue
for frame in reversed(ways._display_frames(self.tiles[peer])):
if self.display_rect(peer, frame["display"]).contains(point):
return peer, frame["display"]
return None, None
def _can_resize(self, peer):
return not self.read_only and peer in self.tiles and peer not in self.shelf_ids
def _resize_grip_rect(self, peer):
if not self._can_resize(peer) or peer not in (self.selected, self._hover):
return None
rect = self.tile_rect(peer)
size = min(RESIZE_GRIP, rect.width(), rect.height())
grip = QRectF(rect.right()-size, rect.bottom()-size, size, size)
for other, tile in self.tiles.items():
if other == peer or other in self.shelf_ids:
continue
for display in tile.get("display_offsets", {}):
if display in tile.get("displays", {}) and grip.intersects(self.display_rect(other, display)):
return None
return grip
def _resize_at(self, point):
# An edge third's 5 px band wins over a grip it overlaps: the selected peer's and the
# hovered tile's corners sit on the end third of a shared side.
if self._third_segment_at(point) is not None:
return None
for peer in reversed(list(self.tiles)):
grip = self._resize_grip_rect(peer)
# A tile drawn smaller than the grip has its whole grip inside the band of the side it
# shares; the hit area keeps the full grip size, reaching out past the corner.
if grip is not None and QRectF(grip.left(), grip.top(), max(grip.width(), RESIZE_GRIP),
max(grip.height(), RESIZE_GRIP)).contains(point):
return peer
return None
def _geometry(self):
self._sync_recentre()
if self._drag:
return
visible = {key: tile for key, tile in self.tiles.items() if key not in self.shelf_ids}
if not visible:
self._bounds, self._scale = (0, 0, 1, 1), 1.0
self._origin = QPointF(12, 12)
return
frames = [frame for tile in visible.values() for frame in ways._display_frames(tile)]
left = min([tile["x"] for tile in visible.values()] + [frame["x"] for frame in frames])
top = min([tile["y"] for tile in visible.values()] + [frame["y"] for frame in frames])
right = max([tile["x"] + tile["w"] for tile in visible.values()] +
[frame["x"] + frame["w"] for frame in frames])
bottom = max([tile["y"] + tile["h"] for tile in visible.values()] +
[frame["y"] + frame["h"] for frame in frames])
cx, cy = (left+right)/2, (top+bottom)/2
self._bounds = (cx, cy, right-left, bottom-top)
room_w, room_h = max(1, self.width()-24), max(1, self.height()-24)
self._scale = min(room_w/max(1, right-left), room_h/max(1, bottom-top), 1.0)
self._origin = QPointF(self.width()/2, self.height()/2)
def resizeEvent(self, event):
self._geometry()
if self.ledger_height:
self._height_timer.start(0)
super().resizeEvent(event)
def _fit_ledger_height(self):
target = 220 if self.width() < 620 else 260
if self.minimumHeight() != target or self.maximumHeight() != target:
self.setFixedHeight(target)
self.updateGeometry()
def _recentre_side(self):
own_id = self._own_id()
if (own_id not in self.tiles or self.selected not in self.tiles
or self.selected == own_id or self.selected in self.shelf_ids):
return None
own, tile = self.tiles[own_id], self.tiles[self.selected]
contact = ways._rect_contact(own, tile)
if contact and contact[0] != "corner":
return contact[0]
targets = {side: ways.place_beside({own_id: own, self.selected: tile},
own_id, self.selected, side) for side in ways.EDGES}
return min(targets, key=lambda side: (targets[side]["x"]-tile["x"])**2
+ (targets[side]["y"]-tile["y"])**2)
def _can_recentre(self):
if self.read_only:
return False
side = self._recentre_side()
if side is None:
return False
own_id = self._own_id()
tile = self.tiles[self.selected]
centred = ways.place_beside({own_id: self.tiles[own_id], self.selected: tile},
own_id, self.selected, side)
return (tile["x"], tile["y"]) != (centred["x"], centred["y"])
def _sync_recentre(self):
button = self.recentre_button
button.move(self.width()-button.width()-10, 10)
button.setAccessibleName(tr("Recentre {name}").format(name=self.labels.get(self.selected, tr(OTHER))))
colours = tuple(theme.colour(name) for name in ("panel", "ink_3", "ink", "edge", "ink_2"))
if colours != self._recentre_colours:
panel, ink_3, ink, edge, ink_2 = colours
button.setStyleSheet(
f"QPushButton {{ background: {panel}; color: {ink_3};"
" border: 1px solid transparent; border-radius: 4px; padding: 3px 8px; }"
f"QPushButton:hover {{ color: {ink}; border-color: {edge}; }}"
f"QPushButton:focus {{ border-color: {ink_2}; }}")
self._recentre_colours = colours
button.setVisible(self._can_recentre())
button.raise_()
def _commit_tile(self, peer, resized=False):
if self.read_only:
return
accepted = self.on_drop({key: dict(tile) for key, tile in self.tiles.items()}, peer) is not False
if accepted:
if resized:
self.announce(tr("{name} resized.").format(name=self.labels.get(peer, tr(OTHER))))
else:
self._announce_move(peer)
self._geometry()
self.update()
def recentre(self):
if self._drag is not None or not self._can_recentre():
return
peer = self.selected
active = {key: tile for key, tile in self.tiles.items() if key not in self.shelf_ids}
target = ways.place_beside(active, self._own_id(), peer, self._recentre_side())
self.animate_tile(peer, target, done=lambda: self._commit_tile(peer))
def snap_preview(self):
if not self._drag or self._resizing or self._drag == self._own_id() or self._drag_display is not None:
return None
tile = self.tiles[self._drag]
others = {key: value for key, value in self.tiles.items()
if key != self._drag and key not in self.shelf_ids}
radius = 12 / max(self._scale, 0.001)
snapped = ways.snap_position(tile, self._own_id(), others, radius=radius)
if ((snapped["x"], snapped["y"]) != (tile["x"], tile["y"])
and ways.within_snap_radius(tile, snapped, self._own_id(), others, radius)):
return {**tile, **snapped}
return None
def _paint_contact(self, painter, tile, rect, contact, colour="signal", alpha=1.0, breaks=(), screen=None):
side, start, end = contact
width = 4.0 if colour == "signal" else 2.0
painter.setBrush(Qt.BrushStyle.NoBrush)
pen = QPen(_colour(colour, alpha), width,
Qt.PenStyle.SolidLine if colour == "signal" else Qt.PenStyle.DashLine)
pen.setCapStyle(Qt.PenCapStyle.RoundCap)
painter.setPen(pen)
if side == "corner":
x = self._edge_px(tile, rect, screen or tile, "left" if start.endswith("left") else "right")
y = self._edge_px(tile, rect, screen or tile, "top" if start.startswith("top") else "bottom")
painter.setPen(Qt.PenStyle.NoPen)
painter.setBrush(_colour(colour, alpha))
painter.drawEllipse(QPointF(x, y), 3.5, 3.5)
else:
self._paint_seam(painter, tile, rect, contact, alpha, width, breaks, screen)
def _paint_seam(self, painter, tile, rect, contact, alpha, width, breaks, screen=None):
line = self.seam_line(tile, rect, contact, breaks, width, screen)
if line is None:
return
one, two = line
self.seam_paths.append((contact[0], one, two, alpha, width))
painter.drawLine(one, two)
def seam_line(self, tile, rect, contact, breaks=(), width=0.0, screen=None):
"""Pixel endpoints shared by the seam and its ghost track, including corner halos, on the edge
of `screen` (one of the tile's display frames) or of the tile. An end at one of `breaks`, a third
boundary in layout units, stops short enough that a round cap of `width` leaves half of THIRD_GAP
clear; a piece with such an end and no length left is None."""
side, start, end = contact
vertical = side in ("left", "right")
origin = tile["y"] if vertical else tile["x"]
low = (rect.top() if vertical else rect.left()) + (start - origin) * self._scale
high = (rect.top() if vertical else rect.left()) + (end - origin) * self._scale
first, last = (rect.top(), rect.bottom()) if vertical else (rect.left(), rect.right())
low_inset = high_inset = min(2.0, max(0.0, (high - low) / 2))
broken = False
if any(abs(start - point) < 1e-6 for point in breaks):
low_inset, broken = THIRD_GAP / 2 + width / 2, True
if any(abs(end - point) < 1e-6 for point in breaks):
high_inset, broken = THIRD_GAP / 2 + width / 2, True
if broken and high - high_inset <= low + low_inset:
return None
if tile is self.tiles.get(self._own_id()):
corners = self._pad_corners()
near, far = {"top": ("top_left", "top_right"), "bottom": ("bottom_left", "bottom_right"),
"left": ("top_left", "bottom_left"), "right": ("top_right", "bottom_right")}[side]
if near in corners and abs(low - first) < 2.1:
low_inset = 11
if far in corners and abs(high - last) < 2.1:
high_inset = 11
fixed = self._edge_px(tile, rect, screen or tile, side)
return ((QPointF(fixed, low + low_inset), QPointF(fixed, max(low + low_inset, high - high_inset)))
if vertical else (QPointF(low + low_inset, fixed), QPointF(max(low + low_inset, high - high_inset), fixed)))
def _edge_px(self, tile, rect, screen, side):
"""Where `screen`'s `side`, in layout units, falls in pixels across `tile`'s `rect`."""
if side in ("left", "right"):
return rect.left() + (screen["x"] + (screen["w"] if side == "right" else 0) - tile["x"]) * self._scale
return rect.top() + (screen["y"] + (screen["h"] if side == "bottom" else 0) - tile["y"]) * self._scale
def _side_contacts(self, peer):
"""[(screen, contact)]: this machine's display frames that meet `peer`'s along a side, as the
engine finds them; thirds are measured along `screen`, the pointer's own display."""
return ways.side_contacts(self.tiles[self._own_id()], self.tiles[peer])
def _pad_corners(self):
"""Every corner of This PC that carries a pad, whichever machine holds it."""
return {corner for peer, data in self.states.items()
if peer in self.tiles and peer not in self.shelf_ids and peer != self._own_id()
for corner in data.get("corners", ()) if corner in pages_win.CORNER_NAMES}
@staticmethod
def _wrap_sides(data):
"""The sides of This PC a machine's wrap-around crosses by now, each once, in map order."""
sides = {item["side"] if isinstance(item, dict) else item for item in data.get("wraps", ())}
return [side for side in ways.EDGES if side in sides]
def wrap_seam(self, rect, side):
"""Pixel endpoints of a wrap-around seam along one of This PC's own sides: inset 2 px at each
end, or 13 px where a corner pad sits on that vertex, so it stops at the pad's halo."""
pads = self._pad_corners()
vertical = side in ("left", "right")
first, last = (rect.top(), rect.bottom()) if vertical else (rect.left(), rect.right())
near, far = {"top": ("top_left", "top_right"), "bottom": ("bottom_left", "bottom_right"),
"left": ("top_left", "bottom_left"), "right": ("top_right", "bottom_right")}[side]
low = first + (13 if near in pads else 2)
high = max(low, last - (13 if far in pads else 2))
fixed = rect.left() if side == "left" else rect.right() if side == "right" else rect.top() if side == "top" else rect.bottom()
return (QPointF(fixed, low), QPointF(fixed, high)) if vertical else (QPointF(low, fixed), QPointF(high, fixed))
@staticmethod
def _paint_push_arrow(painter, tip, side, colour):
dx, dy = {"left": (-1, 0), "right": (1, 0), "top": (0, -1), "bottom": (0, 1)}[side]
pen = QPen(colour, 1.6)
pen.setCapStyle(Qt.PenCapStyle.RoundCap)
pen.setJoinStyle(Qt.PenJoinStyle.RoundJoin)
painter.setPen(pen)
painter.setBrush(Qt.BrushStyle.NoBrush)
painter.drawLine(QPointF(tip.x() - dx * 9, tip.y() - dy * 9), tip)
path = QPainterPath(QPointF(tip.x() - dx * 4 - dy * 4, tip.y() - dy * 4 - dx * 4))
path.lineTo(tip)
path.lineTo(QPointF(tip.x() - dx * 4 + dy * 4, tip.y() - dy * 4 + dx * 4))
painter.drawPath(path)
def _paint_wrap(self, painter, rect, side, name, kept, alpha, peer=None):
"""A wrap-around side: the seam along This PC's own edge and, inside the tile, where it leads."""
one, two = self.wrap_seam(rect, side)
if kept:
pen = QPen(_colour("signal", .35), 2.0)
pen.setDashPattern([2.0, 2.5])
else:
pen = QPen(_colour("signal", alpha), 4.0)
pen.setCapStyle(Qt.PenCapStyle.RoundCap)
painter.setPen(pen)
painter.setBrush(Qt.BrushStyle.NoBrush)
painter.drawLine(one, two)
self.seam_paths.append((side, one, two, .35 if kept else alpha, pen.widthF()))
text = "wrap kept, Edge off" if kept else f"wraps to {name}"
self.wrap_marks.append((peer, side, text, kept, .35 if kept else alpha))
def _paint_wrap_labels(self, painter, rect, marks):
"""Each wrap label gets its own row below This PC's name and detail line, so none ever lands on
them or on another label: a top side's row nearest the name, a bottom side's nearest the
bottom edge, left and right in between, sharing one row when both fit. Sides that say the
same thing, as when one machine wraps on several, share one label naming them. Rows that do
not fit the tile are left out; the seam still shows the side."""
self.wrap_label_rects = []
if rect.height() < 78:
return
painter.setFont(theme.font(tokens.TYPE["small"]))
metrics = painter.fontMetrics()
order = {"merged": 0, "top": 0, "left": 1, "right": 2, "bottom": 3}
said = {}
for side, text, kept, alpha in sorted(marks, key=lambda mark: order[mark[0]]):
said.setdefault((text, kept), []).append((side, text, kept, alpha))
labels = []
for same in said.values():
side, text, kept, alpha = same[0]
if len(same) > 1:
# The sides named, else counted, else the plain words: the seams still show which.
text = next((option for option in (f"{text} · {', '.join(mark[0] for mark in same)}",
f"{text} · {len(same)} sides")
if metrics.horizontalAdvance(option) <= rect.width() - 24), text)
side = "merged"
room = rect.width() - (52 if side in ("left", "right") else 24)
text = metrics.elidedText(text, Qt.TextElideMode.ElideRight, max(1, round(room)))
labels.append((side, text, kept, alpha, metrics.horizontalAdvance(text)))
rows = []
for label in sorted(labels, key=lambda label: order[label[0]]):
if (label[0] == "right" and rows and len(rows[-1]) == 1 and rows[-1][0][0] == "left"
and 26 + rows[-1][0][4] + 8 + label[4] + 26 <= rect.width()):
rows[-1].append(label)
else:
rows.append([label])
first, last = rect.top() + 51, rect.bottom() - 22
room = int((last - first) // 18) + 1 if last >= first else 0
wanted = {"top": first, "merged": first, "left": rect.center().y() + 10,
"right": rect.center().y() + 10, "bottom": last}
tops = []
for row in rows[:room]:
tops.append(max(min(last, wanted[row[0][0]]), tops[-1] + 18 if tops else first))
for index in range(len(tops) - 1, -1, -1):
tops[index] = min(tops[index], last if index == len(tops) - 1 else tops[index + 1] - 18)
for top, row in zip(tops, rows):
for side, text, kept, alpha, width in row:
ink = _colour("ink_3", .8) if kept else _colour("signal", alpha)
x = (rect.left() + 26 if side == "left" else rect.right() - 26 - width if side == "right"
else rect.right() - 12 - width)
box = QRectF(x, top, width + 1, 16)
if side in ("left", "right"):
self._paint_push_arrow(painter, QPointF(rect.left() + 16 if side == "left" else rect.right() - 16,
box.center().y()), side, ink)
painter.setFont(theme.font(tokens.TYPE["small"]))
painter.setPen(ink)
painter.drawText(box, Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter, text)
self.wrap_label_rects.append((side, text, box))
def _third_segment_at(self, point):
if self.read_only:
return None
own_id, peer = self._own_id(), self.selected
if (own_id not in self.tiles or peer not in self.tiles or peer == own_id
or peer in self.shelf_ids):
return None
own_rect, own = self.tile_rect(own_id), self.tiles[own_id]
for screen, contact in self._side_contacts(peer):
side = contact[0]
edge = self._edge_px(own, own_rect, screen, side)
for third, _side, low, high in ways.third_stretches(contact, screen):
if side in ("left", "right"):
y1 = own_rect.top() + (low - own["y"]) * self._scale
y2 = own_rect.top() + (high - own["y"]) * self._scale
hit = abs(point.x() - edge) <= 5 and y1 <= point.y() <= y2
else:
x1 = own_rect.left() + (low - own["x"]) * self._scale
x2 = own_rect.left() + (high - own["x"]) * self._scale
hit = abs(point.y() - edge) <= 5 and x1 <= point.x() <= x2
if hit:
return peer, third, side
return None
def _third_at(self, point):
hit = self._third_segment_at(point)
return hit[:2] if hit else None
def _third_tooltip(self, peer, third, side):
picked = self.states.get(peer, {}).get("thirds", [])
name = ways.part_names(side)[third]
return f"{name} third: click to {'leave it out' if third in picked else 'turn it on'}"
@staticmethod
def _paint_corner_pad(painter, rect, corner, opacity):
x = rect.left() if corner.endswith("left") else rect.right()
y = rect.top() if corner.startswith("top") else rect.bottom()
painter.setPen(Qt.PenStyle.NoPen)
painter.setBrush(_colour("ground"))
painter.drawRoundedRect(QRectF(x - 11, y - 11, 22, 22), 5, 5)
painter.setBrush(_colour("signal", opacity))
painter.drawRoundedRect(QRectF(x - 8, y - 8, 16, 16), 4, 4)
dx = 1 if corner.endswith("left") else -1
dy = 1 if corner.startswith("top") else -1
pen = QPen(_colour("ground", opacity), 1.8)
pen.setCapStyle(Qt.PenCapStyle.RoundCap)
painter.setPen(pen)
# The 7 px bracket centred on the vertex, as in the 16 px pad around it.
point = QPointF(x - 3.5 * dx, y - 3.5 * dy)
painter.drawLine(point, QPointF(point.x() + 7 * dx, point.y()))
painter.drawLine(point, QPointF(point.x(), point.y() + 7 * dy))
def _paint_third_track(self, painter, own, rect, stretch, breaks=(), screen=None):
_third, side, low, high = stretch
pen = QPen(_colour("signal", 0.3), 2.0)
pen.setCapStyle(Qt.PenCapStyle.RoundCap)
painter.setPen(pen)
self._paint_seam(painter, own, rect, (side, low, high), .3, 2.0, breaks, screen)
@staticmethod
def _title_top(rect):
if rect.height() < 32:
return rect.top() + 11
if rect.height() < 44:
return rect.top() + max(12, rect.height() - 21)
return rect.top() + (4 if rect.height() < 56 else 7)
def _shows_cycle(self, peer):
return (not self.remote and not self.read_only and self.cycle_mode == "ticked"
and peer != self._own_id() and peer not in self.shelf_ids)
@staticmethod
def _cycle_box(rect):
"""The shortcut-cycle tick: its own column at the right end of the name's line, or in the
bottom row of a tile 44 to 56pt tall, leaving its corner free for the resize grip."""
if rect.height() < 32:
return QRectF(rect.right() - 15, rect.top() + 1, 10, 10)
if 44 <= rect.height() < 56:
return QRectF(rect.right() - RESIZE_GRIP - 4 - CYCLE_BOX,
rect.bottom() - 4 - CYCLE_BOX, CYCLE_BOX, CYCLE_BOX)
margin = RESIZE_GRIP + 4 if rect.height() < 44 else 8
title_half = 10 if rect.height() < 56 else 11
return QRectF(rect.right() - margin - CYCLE_BOX, AtlasCanvas._title_top(rect) + title_half - CYCLE_BOX/2,
CYCLE_BOX, CYCLE_BOX)
@staticmethod
def _cycle_hit_rect(rect):
return AtlasCanvas._cycle_box(rect).adjusted(-4, -4, 4, 4)
def _title_rect(self, peer, rect):
return self._beside_display_numbers(self._title_without_numbers(peer, rect),
[box for _, _, box in self._display_number_boxes(peer, rect)])
def _title_without_numbers(self, peer, rect):
"""The name's text rect. Beside the shortcut-cycle tick the name stays centred on the tile while
it fits the room left symmetric by the tick, else takes the room left of the tick; a tile 44 to
56pt tall puts the name on its own row above the tick, 20pt tall so a 44pt tile still fits both."""
if rect.height() < 32:
return QRectF(rect.left() + 5, rect.top() + 11, max(1, rect.width() - 10), max(1, rect.height() - 12))
if not self._shows_cycle(peer):
return QRectF(rect.left()+8, self._title_top(rect), max(1, rect.width()-16),
20 if rect.height() < 56 else 22)
if 44 <= rect.height() < 56:
return QRectF(rect.left()+8, rect.top()+4, max(1, rect.width()-16), 20)
room = 8 + CYCLE_BOX + 6
label = self.labels.get(peer, f"Machine · {peer[-6:]}")
if (rect.height() >= 56 and QFontMetrics(theme.font(tokens.TYPE["body"], 650)).horizontalAdvance(label)
<= rect.width() - 2*room):
return QRectF(rect.left()+room, self._title_top(rect), rect.width()-2*room, 22)
return QRectF(rect.left()+8, self._title_top(rect), max(1, self._cycle_box(rect).left()-6-rect.left()-8),
20 if rect.height() < 56 else 22)
def _display_number_boxes(self, peer, rect):
tile = self.tiles[peer]
boxes = []
for display, number in display_numbers(tile).items():
frame = self.display_rect(peer, display) if tile.get("displays") else rect
if rect.height() < 32:
box = QRectF(frame.left() + 5, frame.top() + 1, 12, 8)
elif rect.height() < 44:
box = QRectF(frame.left() + 5, frame.top() + 1, 14, 10)
elif rect.height() < 56:
box = QRectF(frame.left() + 5, frame.bottom() - 15, 16, 14)
else:
box = QRectF(frame.left() + 5, frame.bottom() - 21, 18, 16)
boxes.append((display, number, box))
return boxes
@staticmethod
def _beside_display_numbers(row, badges):
spans = [(row.left(), row.right())]
for badge in badges:
if badge.bottom() < row.top() or badge.top() > row.bottom():
continue
spans = [(a, b) for left, right in spans
for a, b in ((left, min(right, badge.left() - 4)),
(max(left, badge.right() + 4), right)) if b > a]
left, right = max(spans, key=lambda span: span[1] - span[0], default=(row.left(), row.left()))
return QRectF(left, row.top(), max(0, right - left), row.height())
def paintEvent(self, _event):
self._geometry()
self.display_number_rects = []
self.seam_paths = []
self.wrap_marks = []
self.wrap_label_rects = []
painter = QPainter(self)
painter.setRenderHint(QPainter.RenderHint.Antialiasing)
painter.setPen(QPen(_colour("edge"), 1.0))
painter.setBrush(_colour("ground"))
painter.drawRoundedRect(QRectF(0.5, 0.5, self.width()-1, self.height()-1), 4, 4)
own_id = self._own_id()
if own_id in self.tiles:
own_rect = self.tile_rect(own_id)
painter.setPen(QPen(_colour("edge", 0.22), 1.0))
for fraction in (1.0/3.0, 2.0/3.0):
x = own_rect.left() + own_rect.width()*fraction
y = own_rect.top() + own_rect.height()*fraction
painter.drawLine(QPointF(x, 4), QPointF(x, self.height()-4))
painter.drawLine(QPointF(4, y), QPointF(self.width()-4, y))
for peer, tile in self.tiles.items():
if peer in self.shelf_ids:
continue
rect = self.tile_rect(peer)
state = self.states.get(peer, {}).get("state", "edge")
chosen = peer == self.selected
is_own = peer == own_id
inactive = peer in self.shelf_ids or self.in_use.get(peer, True) is False
fill = "well" if is_own else "panel"
line = "edge" if is_own else "ink_2" if chosen else "amber" if state in ("gap", "between", "set-elsewhere", "overlap") else "edge"
if self.profile_mode:
line = "ink_2" if self.remote and is_own else "edge"
if inactive:
fill, line = "ground", "ink_2" if chosen and not is_own else "rule"
painter.setOpacity(0.55 if inactive else 1.0)
outlined = (self.remote and is_own) if self.profile_mode else (chosen and not is_own)
painter.setPen(QPen(_colour(line), 2.0 if outlined else 1.0))
painter.setBrush(_colour(fill))
painter.drawRoundedRect(rect, tokens.RADIUS["button"], tokens.RADIUS["button"])
displays = tile.get("displays") or {}
number_boxes = self._display_number_boxes(peer, rect)
badge_rects = [box for _, _, box in number_boxes]
if isinstance(displays, dict) and len(displays) > 1:
for screen in ways._display_frames(tile):
screen_rect = self.display_rect(peer, screen["display"]).adjusted(2, 2, -2, -2)
painter.setPen(QPen(_colour("edge"), 1.0))
painter.setBrush(_colour("well"))
painter.drawRoundedRect(screen_rect, 2, 2)
state_data = self.states.get(peer, {})
dot_colour = "signal" if state_data.get("linked") else "amber" if state_data.get("legacy") else "ink_3"
if self.profile_mode:
dot_colour = "signal" if state_data.get("profile_word") in (tr("Desk"), tr("Own")) else "ink_3"
painter.setPen(Qt.PenStyle.NoPen)
painter.setBrush(_colour(dot_colour))
if rect.height() >= 56:
painter.drawEllipse(QPointF(rect.left()+15, rect.top()+39), 3, 3)
if self._hover == peer and not chosen and not is_own:
painter.setPen(QPen(_colour("ink_3"), 1.0))
painter.setBrush(Qt.BrushStyle.NoBrush)
painter.drawRoundedRect(rect, 4, 4)
sentence_keys = state_data.get("sentence_keys", [])
legacy = state_data.get("legacy", False)
painter.setPen(_colour("ink"))
painter.setFont(theme.font(10 if rect.height() < 32 else tokens.TYPE["body"], 650))
title = self.labels.get(peer, f"Machine · {peer[-6:]}")
title_room = self._title_rect(peer, rect)
painter.drawText(title_room, Qt.AlignmentFlag.AlignCenter,
painter.fontMetrics().elidedText(title, Qt.TextElideMode.ElideRight,
max(1, round(title_room.width()))))
detail = state_data.get("profile_word", "") if self.profile_mode else state_data.get("detail", "")
if detail and rect.height() >= 56:
painter.setPen(_colour("ink_2"))
painter.setFont(theme.font(tokens.TYPE["note"]))
detail_room = self._beside_display_numbers(
QRectF(rect.left()+24, rect.top()+31, max(1, rect.width()-32), 16), badge_rects)
painter.drawText(detail_room,
Qt.AlignmentFlag.AlignBottom | Qt.AlignmentFlag.AlignLeft,
painter.fontMetrics().elidedText(detail, Qt.TextElideMode.ElideRight,
max(1, round(detail_room.width()))))
if legacy and rect.height() >= 78:
painter.setPen(_colour("amber"))
painter.setFont(theme.font(tokens.TYPE["note"]))
painter.drawText(rect.adjusted(7, rect.height()-62, -7, -36),
Qt.AlignmentFlag.AlignCenter | Qt.TextFlag.TextWordWrap,
state_data.get("legacy_label", ""))
if inactive and rect.height() >= 78:
label = "Left out" if peer in self.shelf_ids else "Not in use"
painter.setPen(_colour("ink_3"))
painter.setFont(theme.font(tokens.TYPE["note"]))
painter.drawText(rect.adjusted(4, 0, -4, -6), Qt.AlignmentFlag.AlignBottom | Qt.AlignmentFlag.AlignHCenter, label)
foot = ("" if is_own else "Offline" if state_data.get("linked") is False else
"Crosses" if state_data.get("corners") or state_data.get("wraps") else
"Edge off" if state_data.get("edge_off") else
"Drag to connect" if state == "gap" else "Overlaps" if state == "overlap" else
outcome_for_tile(state, state_data.get("crosses", is_own), is_own,
state_data.get("other_name", "")))
if foot and (not legacy or self.profile_mode) and rect.height() >= 78:
painter.setPen(_colour("signal" if foot == "Crosses" else "amber" if foot in
("Drag to connect", "Overlaps") else "ink_3"))
painter.setFont(theme.font(tokens.TYPE["note"]))
footer_room = self._beside_display_numbers(
QRectF(rect.left()+7, rect.bottom()-24, max(1, rect.width()-14), 16), badge_rects)
painter.drawText(footer_room, Qt.AlignmentFlag.AlignBottom | Qt.AlignmentFlag.AlignHCenter,
painter.fontMetrics().elidedText(foot, Qt.TextElideMode.ElideRight,
max(1, round(footer_room.width()))))
for display, number, number_box in number_boxes:
self.display_number_rects.append((peer, display, number, number_box))
painter.setPen(QPen(_colour("edge"), 1.0))
painter.setBrush(_colour("ground"))
painter.drawRoundedRect(number_box, 3, 3)
painter.setFont(theme.mono_font(7 if rect.height() < 32 else 8 if rect.height() < 44 else 10, 700))
painter.setPen(_colour("ink"))
painter.drawText(number_box, Qt.AlignmentFlag.AlignCenter, str(number))
if self._shows_cycle(peer):
box = self._cycle_box(rect)
ticked = bool(self.cycle.get(peer, True))
painter.setPen(Qt.PenStyle.NoPen if ticked else QPen(_colour("edge"), 1.0))
painter.setBrush(_colour("ink_2" if ticked else "well"))
painter.drawRoundedRect(box, 3, 3)
if ticked:
pen = QPen(_colour("ground"), 1.8)
pen.setCapStyle(Qt.PenCapStyle.RoundCap)
pen.setJoinStyle(Qt.PenJoinStyle.RoundJoin)
painter.setPen(pen)
painter.setBrush(Qt.BrushStyle.NoBrush)
tick_scale = box.width() / CYCLE_BOX
check = QPainterPath(QPointF(box.left()+4.5*tick_scale, box.top()+8.5*tick_scale))
check.lineTo(box.left()+7*tick_scale, box.top()+11*tick_scale)
check.lineTo(box.left()+11.5*tick_scale, box.top()+5*tick_scale)
painter.drawPath(check)
painter.setOpacity(1.0)
own_id = self._own_id()
if own_id in self.tiles:
own = self.tiles[own_id]
own_rect = self.tile_rect(own_id)
for peer, tile in self.tiles.items():
if peer == own_id or peer in self.shelf_ids:
continue
held = self.states.get(peer, {})
seam_alpha = 1.0 if held.get("linked", True) else .55
sides = self._side_contacts(peer)
contact = ways._rect_contact(own, tile)
# Only a machine reached at a corner alone keeps the corner dot; corners where two
# displays meet beside a side contact are not marks.
found = sides or ([(own, contact)] if contact and contact[0] == "corner" else [])
if not found:
continue
if peer == self.selected and sides and (
(held.get("state") in ("edge", "part") or held.get("unpicked"))
and held.get("thirds")):
lit_thirds = held.get("lit", held.get("thirds", []))
for screen, contact in sides:
stretches = ways.third_stretches(contact, screen)
breaks = [before[3] for before, after in zip(stretches, stretches[1:])
if before[1] == after[1] and abs(before[3] - after[2]) < 1e-6]
lit_group = None
for stretch in stretches:
if stretch[0] in lit_thirds:
if (lit_group and lit_group[1] == stretch[1]
and abs(lit_group[3] - stretch[2]) < 1e-6):
lit_group = (lit_group[0], lit_group[1], lit_group[2], stretch[3])
else:
if lit_group:
self._paint_contact(painter, own, own_rect,
(lit_group[1], lit_group[2], lit_group[3]),
alpha=seam_alpha, breaks=breaks, screen=screen)
lit_group = stretch
else:
if lit_group:
self._paint_contact(painter, own, own_rect,
(lit_group[1], lit_group[2], lit_group[3]),
alpha=seam_alpha, breaks=breaks, screen=screen)
lit_group = None
self._paint_third_track(painter, own, own_rect, stretch, breaks, screen)
if lit_group:
self._paint_contact(painter, own, own_rect,
(lit_group[1], lit_group[2], lit_group[3]),
alpha=seam_alpha, breaks=breaks, screen=screen)
# The seam is the edge's own mark: a machine reached only by its corner shows the
# corner bracket and no seam.
elif (held.get("state") in ("edge", "part", "corner")
and held.get("crosses") is not False
and set(held.get("methods", ["edge"])) & {"edge", "part"}):
for screen, contact in found:
for stretch in ways.crossing_stretches(contact, screen, held.get("lit", held.get("thirds", []))):
self._paint_contact(painter, own, own_rect, stretch, alpha=seam_alpha, screen=screen)
for peer, data in self.states.items():
if peer == own_id or peer not in self.tiles or peer in self.shelf_ids:
continue
alpha = (1.0 if data.get("linked", True) else .55) * (1.0 if peer == self.selected else .7)
name = self.labels.get(peer, tr(OTHER))
for side in self._wrap_sides(data):
self._paint_wrap(painter, own_rect, side, name, False, alpha, peer)
crossing = set(self._wrap_sides(data))
for side in data.get("kept_wraps", ()):
if side in ways.EDGES and side not in crossing:
self._paint_wrap(painter, own_rect, side, name, True, alpha, peer)
self._paint_wrap_labels(painter, own_rect, [(side, text, kept, alpha)
for _peer, side, text, kept, alpha in self.wrap_marks])
self.corner_marks = []
for peer, data in self.states.items():
if peer == own_id or peer not in self.tiles or peer in self.shelf_ids:
continue
for corner in ways.CORNERS:
if corner not in data.get("corners", ()):
continue
opacity = 1.0 if peer == self.selected else 0.55
self.corner_marks.append((peer, corner, opacity))
self._paint_corner_pad(painter, own_rect, corner, opacity)
else:
self.corner_marks = []
peers = [peer for peer in self.tiles if peer != own_id and peer not in self.shelf_ids]
for index, one in enumerate(peers):
for two in peers[index+1:]:
if not any(self.states.get(peer, {}).get("state") in ("between", "set-elsewhere")
for peer in (one, two)):
continue
contact = ways._rect_contact(self.tiles[one], self.tiles[two])
if contact and not self.profile_mode:
self._paint_contact(painter, self.tiles[one], self.tile_rect(one), contact, "amber")
snapped = self.snap_preview()
if snapped is not None:
left, top, _width, _height = self._bounds
ghost = QRectF((snapped["x"]-left)*self._scale + self._origin.x(),
(snapped["y"]-top)*self._scale + self._origin.y(),
snapped["w"]*self._scale, snapped["h"]*self._scale)
painter.setBrush(Qt.BrushStyle.NoBrush)
painter.setPen(QPen(_colour("signal", 0.4), 1.0, Qt.PenStyle.DashLine))
painter.drawRoundedRect(ghost, tokens.RADIUS["button"], tokens.RADIUS["button"])
contact = ways._rect_contact(self.tiles[own_id], snapped)
if contact:
self._paint_contact(painter, self.tiles[own_id], self.tile_rect(own_id), contact, alpha=0.5)
for peer in self.tiles:
grip = self._resize_grip_rect(peer)
if grip is not None:
pen = QPen(_colour("ink_2"), 1.5)
pen.setCapStyle(Qt.PenCapStyle.RoundCap)
painter.setPen(pen)
for length in (4, 8):
length = min(length, max(1, grip.width()-4))
painter.drawLine(QPointF(grip.right()-3-length, grip.bottom()-3),
QPointF(grip.right()-3, grip.bottom()-3-length))
if self.hasFocus() and self.selected in self.tiles and self._keyboard_focus:
painter.setPen(QPen(_colour("ink_2"), 2.0))
painter.setBrush(Qt.BrushStyle.NoBrush)
painter.drawRoundedRect(self.tile_rect(self.selected).adjusted(-3, -3, 3, 3), 3, 3)
painter.end()
def _own_id(self):
return self.own_id or next((peer for peer, label in self.labels.items() if label == tr(DASHBOARD_NAME)), None)
def mousePressEvent(self, event):
point = event.position()
peer = self._resize_at(point)
if peer is not None and event.button() == Qt.MouseButton.LeftButton:
motion.stop(self, f"tile:{peer}")
self.selected = peer
self._drag = peer
self._resizing = True
self._drag_start = QPointF(point)
self._tile_start = dict(self.tiles[peer])
self._profile_press = None
self.setFocus(Qt.FocusReason.MouseFocusReason)
self._keyboard_focus = False
self.setCursor(Qt.CursorShape.SizeFDiagCursor)
if not self.profile_mode and peer != self._own_id():
self.on_select(peer)
self.update()
event.accept()
return
third = self._third_at(point)
if third is not None:
self._third_press = third
event.accept()
return
if self.profile_mode:
self._profile_press = next((peer for peer in reversed(list(self.tiles))
if self.tile_rect(peer).contains(point)), None)
self._profile_press_point = QPointF(point)
if self._profile_press is not None and (self.read_only or self._profile_press == self._own_id()
or self._profile_press in self.shelf_ids):
self.selected = self._profile_press
self.setFocus(Qt.FocusReason.MouseFocusReason)
self._keyboard_focus = False
self.update()
event.accept()
return
if self.read_only:
event.accept()
return
display_peer, display = self.display_at(point)
if display_peer is not None and display_peer != self._own_id():
offsets = self.tiles[display_peer].get("display_offsets", {})
split = display in offsets
alt = bool(event.modifiers() & Qt.KeyboardModifier.AltModifier)
if split or alt:
motion.stop(self, f"tile:{display_peer}")
self.selected = display_peer
self._drag = display_peer
self._drag_display = display
self._dragged_display = False
self._display_offset_start = dict(offsets.get(display, {"x": 0, "y": 0}))
self._split_on_release = alt and not split
self._group_on_release = alt and split
self._drag_start = QPointF(point)
self._tile_start = dict(self.tiles[display_peer])
self.setFocus(Qt.FocusReason.MouseFocusReason)
self._keyboard_focus = False
if not self.profile_mode:
self.on_select(display_peer)
self.update()
event.accept()
return
for peer in reversed(list(self.tiles)):
if peer in self.shelf_ids:
continue
rect = self.tile_rect(peer)
if rect.contains(point):
if peer == self._own_id():
event.accept()
return
if self._shows_cycle(peer) and self._cycle_hit_rect(rect).contains(point):
self._profile_press = None
self.set_cycle(peer, not self.cycle.get(peer, True))
event.accept()
return
self.selected = peer
motion.stop(self, f"tile:{peer}")
self._drag = peer
self._drag_start = QPointF(point)
self._tile_start = dict(self.tiles[peer])
self.setFocus(Qt.FocusReason.MouseFocusReason)
self._keyboard_focus = False
if not self.profile_mode:
self.on_select(peer)
self.update()
event.accept()
return
super().mousePressEvent(event)
def mouseMoveEvent(self, event):
if self._drag:
self.setCursor(Qt.CursorShape.SizeFDiagCursor if self._resizing else Qt.CursorShape.ClosedHandCursor)
delta = event.position() - self._drag_start
if self._resizing:
self.tiles[self._drag] = ways.resize_from_drag(
self._tile_start, delta.x()/self._scale, delta.y()/self._scale)
elif self._drag_display is not None:
tile = self.tiles[self._drag]
offsets = dict(tile.get("display_offsets", {}))
offsets[self._drag_display] = {
"x": round(self._display_offset_start["x"] + delta.x()/self._scale),
"y": round(self._display_offset_start["y"] + delta.y()/self._scale),
}
self.tiles[self._drag] = {**tile, "display_offsets": offsets}
self._dragged_display = self._dragged_display or not delta.isNull()
else:
tile = self.tiles[self._drag]
self.tiles[self._drag] = {**self._tile_start,
"x": round(self._tile_start["x"] + delta.x()/self._scale),
"y": round(self._tile_start["y"] + delta.y()/self._scale)}
self._geometry()
self.update()
event.accept()
return
third = self._third_segment_at(event.position())
hovered = next((peer for peer in self.tiles if peer not in self.shelf_ids and self.tile_rect(peer).contains(event.position())), None)
if hovered != self._hover:
self._hover = hovered
self.update()
resize_peer = self._resize_at(event.position())
if resize_peer is not None:
self.setToolTip(self.labels.get(resize_peer, ""))
self.setCursor(Qt.CursorShape.SizeFDiagCursor)
elif third is not None:
self.setToolTip(self._third_tooltip(*third))
self.setCursor(Qt.CursorShape.PointingHandCursor)
else:
self.setToolTip(self.labels.get(hovered, "") if hovered else "")
self.setCursor(Qt.CursorShape.OpenHandCursor if hovered and hovered != self._own_id() and not self.read_only
else Qt.CursorShape.PointingHandCursor if hovered and self.profile_mode
else Qt.CursorShape.ArrowCursor)
if resize_peer is None and hovered and self._shows_cycle(hovered) and self._cycle_hit_rect(self.tile_rect(hovered)).contains(event.position()):
QToolTip.showText(self.mapToGlobal(event.position().toPoint()), tr("In the shortcut's cycle"), self)
super().mouseMoveEvent(event)
def leaveEvent(self, event):
self._hover = None
if not self._drag:
self.setCursor(Qt.CursorShape.ArrowCursor)
self.update()
super().leaveEvent(event)
def mouseReleaseEvent(self, event):
profile_peer = self._profile_press
self._profile_press = None
if (self.profile_mode and profile_peer is not None and self._profile_press_point is not None
and not self._split_on_release and not self._group_on_release
and (event.position() - self._profile_press_point).manhattanLength() < 4):
if self._drag is not None:
self.tiles[self._drag] = dict(self._tile_start)
self._geometry()
self._drag = None
self._drag_display = None
self._display_offset_start = None
self._dragged_display = False
self._split_on_release = self._group_on_release = False
self.setCursor(Qt.CursorShape.ArrowCursor)
self.on_edit_machine(profile_peer)
self.update()
event.accept()
return
if self._third_press is not None:
pressed = self._third_press
self._third_press = None
if self._third_at(event.position()) == pressed:
self.on_third(*pressed)
event.accept()
return
peer = self._drag
if peer:
resized = self._resizing
snapped = self.snap_preview()
display = self._drag_display
moved_display = self._dragged_display
split_on_release = self._split_on_release
group_on_release = self._group_on_release
self._drag = None
self._resizing = False
self._drag_display = None
self._display_offset_start = None
self._dragged_display = False
self._split_on_release = False
self._group_on_release = False
self.setCursor(Qt.CursorShape.ArrowCursor)
if resized:
self._commit_tile(peer, resized=True)
event.accept()
return
if display is not None and not moved_display and (split_on_release or group_on_release):
tile = dict(self.tiles[peer])
offsets = dict(tile.get("display_offsets", {}))
if split_on_release:
offsets[display] = {"x": 0, "y": 0}
else:
offsets.pop(display, None)
updated = {**tile, "display_offsets": offsets}
if not offsets:
updated.pop("display_offsets", None)
self.tiles[peer] = updated
self.on_drop({key: dict(value) for key, value in self.tiles.items()}, peer)
self.update()
event.accept()
return
if display is not None and not moved_display:
self.update()
event.accept()
return
if display is None and not self.remote and event.position().y() > self.height() - 4:
self.on_leave_out(peer, True)
self.update()
event.accept()
return
if snapped is not None and snapped != self.tiles[peer]:
self.animate_tile(peer, snapped, done=lambda: self._commit_tile(peer))
else:
self._commit_tile(peer)
self.update()
event.accept()
return
super().mouseReleaseEvent(event)
def mouseDoubleClickEvent(self, event):
if self.remote or self.read_only:
event.accept()
return
peer = next((key for key in self.tiles if key not in self.shelf_ids
and self.tile_rect(key).contains(event.position())), None)
if peer == self._own_id():
if self.on_hint:
self.on_hint(tr("Rename this computer on Overview."))
event.accept()
return
if peer is not None and peer != self._own_id():
self.begin_rename(peer)
event.accept()
return
super().mouseDoubleClickEvent(event)
def keyPressEvent(self, event):
self._keyboard_focus = True
if (self.profile_mode and self.selected in self.tiles
and event.key() in (Qt.Key.Key_Return, Qt.Key.Key_Enter, Qt.Key.Key_Space)):
self.on_edit_machine(self.selected)
event.accept()
return
if self.read_only:
super().keyPressEvent(event)
return
if event.key() == Qt.Key.Key_C and not event.modifiers():
self.recentre()
event.accept()
return
if event.key() in (Qt.Key.Key_F2, Qt.Key.Key_Return, Qt.Key.Key_Enter) and self.selected is not None:
self.begin_rename(self.selected)
event.accept()
return
if (event.key() == Qt.Key.Key_Space and self.cycle_mode == "ticked"
and self.selected in self.tiles and self.selected != self._own_id()):
self.set_cycle(self.selected, not self.cycle.get(self.selected, True))
event.accept()
return
moves = {Qt.Key.Key_Left: (-1, 0), Qt.Key.Key_Right: (1, 0),
Qt.Key.Key_Up: (0, -1), Qt.Key.Key_Down: (0, 1)}
if event.key() in moves and event.modifiers() & Qt.KeyboardModifier.AltModifier:
if self._can_resize(self.selected) and self._drag is None:
peer = self.selected
motion.stop(self, f"tile:{peer}")
tile = self.tiles[peer]
long_side = max(tile["w"], tile["h"])
dx, dy = moves[event.key()]
self.tiles[peer] = ways.resize_tile(tile, long_side + (dx+dy)*long_side/8)
self._commit_tile(peer, resized=True)
event.accept()
return
if event.key() in moves and self.selected in self.shelf_ids:
event.accept()
return
if event.key() in moves and self.selected in self.tiles and self.selected != self._own_id():
dx, dy = moves[event.key()]
own = self.tiles[self._own_id()]
tile = self.tiles[self.selected]
self.tiles[self.selected] = {**tile, "x": tile["x"] + round(own["w"]/3)*dx,
"y": tile["y"] + round(own["h"]/3)*dy}
accepted = self.on_drop({key: dict(value) for key, value in self.tiles.items()}, self.selected) is not False
if accepted:
self._announce_move(self.selected)
self._geometry()
self.update()
event.accept()
return
super().keyPressEvent(event)
def focusNextPrevChild(self, next):
peers = [peer for peer in self.tiles if self.profile_mode or
(peer != self._own_id() and peer not in self.shelf_ids)]
peers.sort(key=lambda peer: (self.tiles[peer]["y"] + self.tiles[peer]["h"] / 2,
self.tiles[peer]["x"] + self.tiles[peer]["w"] / 2))
rows = []
for peer in peers:
tile = self.tiles[peer]
centre = tile["y"] + tile["h"] / 2
if not rows or centre - rows[-1][0][0] > min(tile["h"], rows[-1][0][1]) / 2:
rows.append([])
rows[-1].append((centre, tile["h"], peer))
peers = [peer for row in rows for _centre, _height, peer in
sorted(row, key=lambda item: self.tiles[item[2]]["x"] + self.tiles[item[2]]["w"] / 2)]
if not peers:
return super().focusNextPrevChild(next)
index = peers.index(self.selected) if self.selected in peers else (-1 if next else len(peers))
target = index + (1 if next else -1)
if 0 <= target < len(peers):
self.selected = peers[target]
if not self.profile_mode:
self.on_select(self.selected)
self._keyboard_focus = True
self.update()
return True
return super().focusNextPrevChild(next)
def _announce_move(self, peer):
own = self.tiles.get(self._own_id())
contact = ways._rect_contact(own, self.tiles[peer]) if own else None
tile = self.tiles[peer]
if contact and contact[0] != "corner":
side = contact[0]
elif own:
dx = tile["x"] + tile["w"] / 2 - own["x"] - own["w"] / 2
dy = tile["y"] + tile["h"] / 2 - own["y"] - own["h"] / 2
side = ("left" if dx < 0 else "right") if abs(dx) >= abs(dy) else ("top" if dy < 0 else "bottom")
else:
side = "corner"
state = self.states.get(peer, {})
position = tr("{side} of This PC").format(side=tr(DIRECTION_NAMES[side])) if side != "corner" else tr("at a corner of This PC")
part = None
if own:
along, start, span = ((tile["y"] + tile["h"] / 2, own["y"], own["h"])
if side in ("left", "right") else
(tile["x"] + tile["w"] / 2, own["x"], own["w"]))
part = ways.ATLAS_PARTS[min(2, max(0, int((along-start) / (span/3))))]
parts = state.get("thirds", [])
chosen_part = parts[0] if parts else part
part_name = pages_win.part_names(side).get(chosen_part, chosen_part) if chosen_part else ""
detail = tr(", {part} third").format(part=tr(ways.PART_NAMES_LOWER[part_name.lower()])) if part_name else ""
result = state.get("announcement", tr("Crosses."))
# Translators: {name} is a machine name; {position} is relative to this PC; {detail} optionally names the third crossed.
message = tr("{name}, {position}{detail}. {result}").format(
name=self.labels.get(peer, OTHER), position=position, detail=detail, result=result)
self.announce(message)
def announce(self, message):
description = message
if not self.read_only and any(peer not in self.shelf_ids for peer in self.tiles):
description += " " + tr(RESIZE_HELP)
self.setAccessibleDescription(description)
QAccessible.updateAccessibility(QAccessibleAnnouncementEvent(self, message))
if self.on_announce:
self.on_announce(message)
def focusInEvent(self, event):
self._keyboard_focus = event.reason() != Qt.FocusReason.MouseFocusReason
self.update()
super().focusInEvent(event)
def begin_rename(self, peer):
if self.remote or self.read_only or peer not in self.tiles or peer in self.shelf_ids or peer == self._own_id():
return
rect = self.tile_rect(peer).toRect()
self.selected = peer
self._rename_peer = peer
self.rename_edit.setGeometry(rect.adjusted(8, rect.height()//3, -8, -rect.height()//3))
self.rename_edit.setText(self.rename_values.get(peer, ""))
self.rename_edit.setVisible(True)
if self.on_rename_state:
self.on_rename_state(True)
self.rename_edit.setFocus(Qt.FocusReason.OtherFocusReason)
self.rename_edit.selectAll()
def _save_rename(self):
peer, value = self._rename_peer, self.rename_edit.text().strip()[:64]
self._rename_peer = None
self.rename_edit.setVisible(False)
if self.on_rename_state:
self.on_rename_state(False)
self.setFocus(Qt.FocusReason.OtherFocusReason)
if peer and not self.remote and not self.read_only:
self.on_rename(peer, value)
def eventFilter(self, watched, event):
if (watched is self.recentre_button and event.type() == event.Type.KeyPress
and event.key() == Qt.Key.Key_C and not event.modifiers()):
self.recentre()
return True
if watched is self.rename_edit and event.type() == event.Type.KeyPress and event.key() == Qt.Key.Key_Escape:
self.rename_edit.setVisible(False)
self._rename_peer = None
if self.on_rename_state:
self.on_rename_state(False)
self.setFocus(Qt.FocusReason.OtherFocusReason)
return True
if watched is self.rename_edit and event.type() == event.Type.FocusOut and self._rename_peer:
self._save_rename()
return super().eventFilter(watched, event)
class PushStrip(QSlider):
"""The Crossing page's one Resistance slider, with its live pressure drawn on the same scale."""
HEIGHT = 72
INSET = 18.0
TRACK_TOP = 20.0
TRACK_HEIGHT = 12.0
def __init__(self, parent: QWidget | None = None) -> None:
super().__init__(Qt.Orientation.Horizontal, parent)
self.setRange(0, MAX_RESISTANCE)
self.setSingleStep(10)
self.setPageStep(50)
self.setAccessibleName(tr("Resistance"))
self.setMinimumHeight(self.HEIGHT)
self.setMaximumHeight(self.HEIGHT)
self.setCursor(Qt.CursorShape.PointingHandCursor)
self._other = tr(OTHER)
self._active_edge = "right"
self._pressure = 0.0
self._crossing = False
self._flash_timer = QTimer(self)
self._flash_timer.setSingleShot(True)
self._flash_timer.setInterval(120)
self._flash_timer.timeout.connect(self._clear_crossing_flash)
self._update_accessibility_description()
self.valueChanged.connect(self._update_value_description)
def minimumSizeHint(self) -> QSize:
return QSize(160, self.HEIGHT)
def set_other_name(self, name: str) -> None:
name = name or tr(OTHER)
if name != self._other:
self._other = name
self.update()
def peer_label_text(self) -> str:
metrics = QFontMetrics(theme.font(tokens.TYPE["eyebrow"], 600))
return metrics.elidedText(self._other.upper(), Qt.TextElideMode.ElideRight,
max(1, round(self.width() / 2 - 16)))
def set_edge(self, edge: str) -> None:
if edge:
self._active_edge = edge
self._update_accessibility_description()
def set_value(self, value: int) -> None:
self.setValue(int(value))
def set_pressure(self, pressure: float, edge: str | None = None, crossed: bool = False) -> None:
self._flash_timer.stop()
self._crossing = bool(crossed)
if edge:
self._active_edge = edge
self._pressure = min(float(MAX_RESISTANCE), max(0.0, float(pressure)))
if self._crossing:
self._flash_timer.start()
self._update_accessibility_description()
self.update()
def _clear_crossing_flash(self) -> None:
self._crossing = False
self._pressure = 0.0
self._update_accessibility_description()
self.update()
def _update_value_description(self, _value: int) -> None:
self._update_accessibility_description()
self.update()
def _update_accessibility_description(self) -> None:
pressure = int(round(self._pressure))
threshold = self.value()
edge = tr(DIRECTION_NAMES[self._active_edge])
description = (tr("Current pressure {pressure} of {threshold} pointer units at the {edge} edge.").format(
pressure=pressure, threshold=threshold, edge=edge) if pressure > 0 else
tr("No push. Current pressure is 0 of {threshold} pointer units.").format(threshold=threshold))
self.setAccessibleDescription(description)
def keyPressEvent(self, event) -> None:
steps = {Qt.Key.Key_Left: -1, Qt.Key.Key_Down: -1, Qt.Key.Key_Right: 1, Qt.Key.Key_Up: 1}
direction = steps.get(event.key())
if direction is not None and event.modifiers() & Qt.KeyboardModifier.AltModifier:
self.setValue(self.value() + direction)
event.accept()
return
super().keyPressEvent(event)
def mousePressEvent(self, event) -> None:
if event.button() == Qt.MouseButton.LeftButton:
self.setSliderDown(True)
self._move_to(event.position().x())
event.accept()
return
super().mousePressEvent(event)
def mouseMoveEvent(self, event) -> None:
if self.isSliderDown():
self._move_to(event.position().x())
event.accept()
return
super().mouseMoveEvent(event)
def mouseReleaseEvent(self, event) -> None:
if self.isSliderDown() and event.button() == Qt.MouseButton.LeftButton:
self._move_to(event.position().x())
self.setSliderDown(False)
event.accept()
return
super().mouseReleaseEvent(event)
def _move_to(self, x: float) -> None:
fraction = (float(x) - self.INSET) / max(1.0, self.width() - 2 * self.INSET)
self.setValue(round(min(1.0, max(0.0, fraction)) * MAX_RESISTANCE))
def paintEvent(self, _event) -> None:
painter = QPainter(self)
painter.setRenderHint(QPainter.RenderHint.Antialiasing)
painter.fillRect(self.rect(), _colour("ground"))
painter.setPen(QPen(_colour("rule"), 1.0))
painter.setBrush(Qt.BrushStyle.NoBrush)
painter.drawRoundedRect(QRectF(0.5, 0.5, self.width() - 1, self.height() - 1), 3, 3)
left = resistance_x(self.width(), 0)
right = resistance_x(self.width(), MAX_RESISTANCE)
span = right - left
track = QRectF(left, self.TRACK_TOP, span, self.TRACK_HEIGHT)
painter.setPen(QPen(_colour("ink_3"), 1.0))
painter.setBrush(_colour("well"))
painter.drawRoundedRect(track, 3, 3)
head = resistance_x(self.width(), self._pressure)
if self._pressure > 0:
painter.setPen(Qt.PenStyle.NoPen)
painter.setBrush(_colour("signal"))
painter.drawRoundedRect(QRectF(left, self.TRACK_TOP + 0.5, max(0.0, head - left),
self.TRACK_HEIGHT - 1), 2.5, 2.5)
thumb_x = resistance_x(self.width(), self.value())
painter.setPen(QPen(_colour("ink"), 2.0))
painter.drawLine(QPointF(thumb_x, 17.5), QPointF(thumb_x, 38.0))
marker = "resistance_flash" if self._crossing else "signal" if self._pressure > 0 else "edge"
painter.setPen(QPen(_colour(marker), 3.0 if self._crossing else 2.0))
painter.drawLine(QPointF(left, 17.0), QPointF(left, 41.0))
if self.hasFocus():
painter.setPen(QPen(_colour("signal"), 1.0))
painter.setBrush(Qt.BrushStyle.NoBrush)
painter.drawRoundedRect(track.adjusted(-3, -3, 3, 3), 4, 4)
painter.setFont(theme.font(tokens.TYPE["eyebrow"], 600))
painter.setPen(_colour("ink_3"))
local_rect = QRectF(8, 2, self.width() / 2 - 8, 15)
peer_rect = QRectF(self.width() / 2, 2, self.width() / 2 - 8, 15)
painter.drawText(local_rect, Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter, tr("THIS PC"))
painter.drawText(peer_rect, Qt.AlignmentFlag.AlignRight | Qt.AlignmentFlag.AlignVCenter,
self.peer_label_text())
for value in range(0, MAX_RESISTANCE + 1, 25):
x = resistance_x(self.width(), value)
major = value % 100 == 0
painter.setPen(QPen(_colour("ink_3" if major else "edge"), 1.0))
painter.drawLine(QPointF(x, track.bottom()), QPointF(x, track.bottom() + (12 if major else 4)))
if major:
painter.setFont(theme.mono_font(tokens.TYPE["eyebrow"]))
painter.setPen(_colour("ink_2"))
painter.drawText(QRectF(x - 22, 52, 44, 17), Qt.AlignmentFlag.AlignCenter, str(value))
painter.end()