Skip to content

One keyboard and mouse for a Mac and a Windows PC over the local network, in either direction.

18.0 KB
Raw Blame
"""The crossing effects' replay into QPainter, against a fake painter that records what it was asked
to draw and in what state, and the overlay window's attributes."""

import math
import os
import subprocess
import unittest
from dataclasses import replace
from types import SimpleNamespace
import sys

sys.path.append(os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))

from core import effects
from core.return_edge import Rect

try:
    from PySide6.QtCore import QPointF, QRect, Qt
    from PySide6.QtGui import QConicalGradient, QLinearGradient, QPainter, QPainterPath, QRadialGradient

    import effect_overlay
except ImportError:  # PySide6 is only in the Windows venv
    effect_overlay = None


class FakePainter:
    """Records every draw with the opacity and composition it was made in, and keeps save/restore
    as QPainter does."""

    def __init__(self):
        self.opacity = 1.0
        self.mode = "source-over-at-start"
        self._stack = []
        self.draws = []
        self.clips = []

    def setClipRect(self, rect):
        self.clips.append((rect.x(), rect.y(), rect.width(), rect.height()))

    def save(self):
        self._stack.append((self.opacity, self.mode))

    def restore(self):
        self.opacity, self.mode = self._stack.pop()

    def setOpacity(self, value):
        self.opacity = value

    def setCompositionMode(self, mode):
        self.mode = mode

    def fillPath(self, path, brush):
        self.draws.append(("fill", path, brush, self.opacity, self.mode))

    def strokePath(self, path, pen):
        self.draws.append(("stroke", path, pen, self.opacity, self.mode))


def gradient(kind, geometry, stops=((0.0, (1, 0, 0, 1)), (1.0, (0, 0, 1, 1)))):
    out = effects.Gradient(kind, geometry)
    for offset, colour in stops:
        out.addColorStop(offset, colour)
    return out


def elements(path):
    return [(path.elementAt(i).type, round(path.elementAt(i).x, 3), round(path.elementAt(i).y, 3))
            for i in range(path.elementCount())]


@unittest.skipIf(effect_overlay is None, "needs PySide6")
class ReplayTests(unittest.TestCase):
    def setUp(self):
        from PySide6.QtWidgets import QApplication

        os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
        self.app = QApplication.instance() or QApplication([])

    def pen_of(self, ops):
        pen = effects.Pen()
        pen.ops = list(ops)
        return pen

    @unittest.skipUnless(sys.platform == "win32", "Windows raster budget")
    def test_replay_sets_serial_rasterisation_before_the_first_paint(self):
        env = dict(os.environ)
        env.pop("QT_NO_GUI_THREADPOOL", None)
        result = subprocess.run(
            [sys.executable, "-c", "import sys; sys.path.insert(0, 'win_app'); import effect_overlay, os; print(os.environ.get('QT_NO_GUI_THREADPOOL'))"],
            cwd=os.path.dirname(os.path.dirname(effect_overlay.__file__)), env=env,
            capture_output=True, text=True, check=True,
        )
        self.assertEqual(result.stdout.strip(), "1")

    def test_every_op_restores_opacity_and_composition(self):
        linear = gradient("linear", (0, 0, 10, 0))
        ops = [
            ("fill", [("M", 0, 0), ("L", 10, 0), ("L", 10, 10), ("Z",)], (1, 0, 0, 1), 0.5, "lighter", "nonzero"),
            ("stroke", [("M", 0, 0), ("L", 10, 10)], linear, 0.25, "source-over", 3.0, "round", "bevel"),
            ("fill", [("M", 0, 0), ("L", 5, 0), ("L", 5, 5), ("Z",)], (0, 1, 0, 1), 1.0, "source-over", "evenodd"),
        ]
        painter = FakePainter()
        effect_overlay.replay(painter, [self.pen_of(ops)])
        self.assertEqual((painter.opacity, painter.mode), (1.0, "source-over-at-start"))
        self.assertEqual(painter._stack, [])
        self.assertEqual([d[0] for d in painter.draws], ["fill", "stroke", "fill"])
        self.assertEqual([d[3] for d in painter.draws], [0.5, 0.25, 1.0])
        self.assertEqual(painter.draws[0][4], QPainter.CompositionMode.CompositionMode_Plus)
        self.assertEqual(painter.draws[1][4], QPainter.CompositionMode.CompositionMode_SourceOver)
        self.assertEqual(painter.draws[0][1].fillRule(), Qt.FillRule.WindingFill)
        self.assertEqual(painter.draws[2][1].fillRule(), Qt.FillRule.OddEvenFill)

    def test_a_stroke_carries_width_cap_and_join(self):
        for cap, join, qcap, qjoin in (
            ("butt", "miter", Qt.PenCapStyle.FlatCap, Qt.PenJoinStyle.MiterJoin),
            ("round", "round", Qt.PenCapStyle.RoundCap, Qt.PenJoinStyle.RoundJoin),
            ("square", "bevel", Qt.PenCapStyle.SquareCap, Qt.PenJoinStyle.BevelJoin),
        ):
            painter = FakePainter()
            op = ("stroke", [("M", 0, 0), ("L", 4, 4)], (1, 1, 1, 1), 1.0, "source-over", 2.5, cap, join)
            effect_overlay.replay(painter, [self.pen_of([op])])
            stroke = painter.draws[0][2]
            self.assertEqual((stroke.widthF(), stroke.capStyle(), stroke.joinStyle()), (2.5, qcap, qjoin))

    def test_every_path_segment(self):
        path = effect_overlay.qpath([("M", 1, 2), ("L", 3, 4), ("Q", 5, 6, 7, 8), ("C", 9, 10, 11, 12, 13, 14), ("Z",)])
        kinds = [kind for kind, _x, _y in elements(path)]
        Move, Line, Curve, Data = (QPainterPath.ElementType.MoveToElement, QPainterPath.ElementType.LineToElement,
                                   QPainterPath.ElementType.CurveToElement, QPainterPath.ElementType.CurveToDataElement)
        # Qt stores a quad as a cubic; the close is a line back to the start.
        self.assertEqual(kinds, [Move, Line, Curve, Data, Data, Curve, Data, Data, Line])
        self.assertEqual(elements(path)[-2][1:], (13.0, 14.0))
        self.assertEqual(elements(path)[-1][1:], (1.0, 2.0))

    def test_a_line_after_a_close_carries_on_from_the_subpath_start(self):
        path = effect_overlay.qpath([("M", 5, 5), ("L", 10, 5), ("Z",), ("L", 5, 10)])
        self.assertEqual(elements(path)[-2][1:], (5.0, 5.0))
        self.assertEqual(elements(path)[-1][1:], (5.0, 10.0))

    def test_every_paint_kind(self):
        colour = (0.2, 0.4, 0.6, 0.8)
        linear = gradient("linear", (0, 0, 10, 0))
        radial = gradient("radial", (1, 2, 3, 4, 5, 6))
        conic = gradient("conic", (math.pi / 2, 7, 8))
        ops = [("fill", [("M", 0, 0), ("L", 1, 1), ("L", 0, 1), ("Z",)], paint, 1.0, "source-over", "nonzero")
               for paint in (colour, linear, radial, conic)]
        painter = FakePainter()
        effect_overlay.replay(painter, [self.pen_of(ops)])
        brushes = [draw[2] for draw in painter.draws]
        self.assertEqual(tuple(round(v, 4) for v in brushes[0].color().getRgbF()), colour)
        self.assertIsInstance(brushes[1].gradient(), QLinearGradient)
        self.assertEqual((brushes[1].gradient().start(), brushes[1].gradient().finalStop()), (QPointF(0, 0), QPointF(10, 0)))
        radial_q = brushes[2].gradient()
        self.assertIsInstance(radial_q, QRadialGradient)
        # canvas's first circle is Qt's focal circle; its second is Qt's centre circle.
        self.assertEqual((radial_q.focalPoint(), radial_q.focalRadius()), (QPointF(1, 2), 3))
        self.assertEqual((radial_q.center(), radial_q.centerRadius()), (QPointF(4, 5), 6))
        conic_q = brushes[3].gradient()
        self.assertIsInstance(conic_q, QConicalGradient)
        self.assertEqual(conic_q.center(), QPointF(7, 8))
        self.assertAlmostEqual(conic_q.angle() % 360.0, 270.0)
        # Reversed: canvas's last stop is Qt's first.
        self.assertEqual([round(p, 6) for p, _c in conic_q.stops()], [0.0, 1.0])
        self.assertEqual(conic_q.stops()[0][1].getRgbF(), (0.0, 0.0, 1.0, 1.0))

    def test_one_qt_gradient_per_gradient_per_frame(self):
        shared = gradient("linear", (0, 0, 10, 0))
        op = ("fill", [("M", 0, 0), ("L", 1, 1), ("L", 0, 1), ("Z",)], shared, 1.0, "source-over", "nonzero")
        painter = FakePainter()
        effect_overlay.replay(painter, [self.pen_of([op, op]), self.pen_of([op])])
        self.assertEqual(len({id(draw[2]) for draw in painter.draws}), 1)

    def test_a_hard_stop_keeps_both_colours(self):
        stops = effect_overlay._stops([(0.0, "a"), (0.5, "b"), (0.5, "c"), (1.0, "d")])
        self.assertEqual([colour for _o, colour in stops], ["a", "b", "c", "d"])
        self.assertLess(stops[1][0], stops[2][0])

    def test_a_real_effect_replays_into_a_real_painter(self):
        from PySide6.QtGui import QImage

        image = QImage(900, 500, QImage.Format.Format_ARGB32_Premultiplied)
        image.fill(0)
        painter = QPainter(image)
        for effect_id in effects.EFFECT_IDS:
            for t in (1.2, 2.5):
                scene = effects.preview_scene(effects.effect(effect_id), t, "edge", ["#ff0000", "#00ff00"])
                effect_overlay.replay(painter, scene["pens"])
        painter.end()


@unittest.skipIf(effect_overlay is None, "needs PySide6")
class GeometryTests(unittest.TestCase):
    def test_union_of_bounds(self):
        a, b = effects.Pen(), effects.Pen()
        a.bounds, b.bounds = (0, 5, 10, 20), (-3, 8, 4, 30)
        self.assertEqual(effect_overlay.union_bounds([a, b, effects.Pen()]), (-3, 5, 10, 30))
        self.assertIsNone(effect_overlay.union_bounds([]))

    def test_the_region_is_the_owning_displays_edge_relative_to_the_desktop(self):
        rects = [Rect(-1920, 0, 1920, 1080), Rect(0, -200, 2560, 1440)]
        origin = (-1920, -200)
        self.assertEqual(effect_overlay.edge_region("left", rects, origin),
                         {"kind": "edge", "edge": "left", "x": 0.0, "y": 200.0, "w": 1.0, "h": 1080.0})
        self.assertEqual(effect_overlay.edge_region("right", rects, origin),
                         {"kind": "edge", "edge": "right", "x": 4479.0, "y": 0.0, "w": 1.0, "h": 1440.0})
        self.assertEqual(effect_overlay.edge_region("top", rects, origin)["y"], 0.0)
        self.assertEqual(effect_overlay.edge_region("bottom", rects, origin)["y"], 1439.0)

    def test_a_push_on_a_shorter_displays_exposed_edge_lights_that_display(self):
        # Side by side, the 1080-high display's bottom edge crosses too, 360 points above the
        # desktop's bottom; the effect belongs there, not on the taller display beside it.
        rects = [Rect(0, 0, 1920, 1080), Rect(1920, 0, 2560, 1440)]
        region = effect_overlay.edge_region("bottom", rects, (0, 0), (100, 1079))
        self.assertEqual((region["x"], region["y"], region["w"]), (0.0, 1079.0, 1920.0))

    def test_part_of_the_edge_lights_only_the_third_being_pushed(self):
        rects = [Rect(0, 0, 1920, 1080)]
        region = effect_overlay.edge_region("right", rects, (0, 0), (1919, 900), "end")
        self.assertEqual((region["x"], region["y"], region["h"]), (1919.0, 720.0, 360.0))
        region = effect_overlay.edge_region("top", rects, (0, 0), (900, 0), "middle")
        self.assertEqual((region["x"], region["w"]), (640.0, 640.0))

    def test_a_third_is_the_display_under_the_pointers_own(self):
        # Stacked, each display's left edge has its own thirds, as PartEdge measures them.
        rects = [Rect(0, 0, 1920, 1080), Rect(0, 1080, 1920, 1080)]
        region = effect_overlay.edge_region("left", rects, (0, 0), (0, 1500), "middle")
        self.assertEqual((region["y"], region["h"]), (1440.0, 360.0))
        region = effect_overlay.edge_region("left", rects, (0, 0), (0, 100), "end")
        self.assertEqual((region["y"], region["h"]), (720.0, 360.0))


@unittest.skipIf(effect_overlay is None, "needs PySide6")
class OverlayTests(unittest.TestCase):
    def setUp(self):
        from PySide6.QtWidgets import QApplication

        os.environ.setdefault("QT_QPA_PLATFORM", "offscreen")
        self.app = QApplication.instance() or QApplication([])

    def test_the_window_never_takes_input_focus_or_a_taskbar_button(self):
        overlay = effect_overlay.EffectOverlay()
        flags = overlay.windowFlags()
        for flag in (Qt.WindowType.Tool, Qt.WindowType.FramelessWindowHint, Qt.WindowType.WindowStaysOnTopHint,
                     Qt.WindowType.WindowTransparentForInput, Qt.WindowType.WindowDoesNotAcceptFocus):
            self.assertTrue(flags & flag, flag)
        self.assertTrue(overlay.testAttribute(Qt.WidgetAttribute.WA_ShowWithoutActivating))
        self.assertTrue(overlay.testAttribute(Qt.WidgetAttribute.WA_TranslucentBackground))

    def test_a_failing_effect_logs_once_and_turns_the_effects_off(self):
        failures = []
        overlay = effect_overlay.EffectOverlay(on_failure=lambda: failures.append(1))
        overlay.configure("skin", "signal")

        def boom(pen, s):
            raise RuntimeError("design bug")

        overlay._fx = effects.Effect("boom", "Boom", "quiet", "", boom, boom, 0.5, 0.5)
        with self.assertLogs(effect_overlay.LOGGER, "ERROR") as logged:
            overlay.push("right", 0.6, False, QPointF(10, 10))
            overlay._tick()
        self.assertEqual(len(logged.records), 1)
        self.assertIn("skin", logged.output[0])
        self.assertTrue(overlay.failed)
        self.assertEqual(failures, [1])
        self.assertTrue(overlay.isHidden())
        overlay.push("right", 0.6, False, QPointF(10, 10))
        self.assertFalse(overlay.player.busy)

    def test_effects_that_cannot_load_turn_themselves_off(self):
        failures = []
        overlay = effect_overlay.EffectOverlay(on_failure=lambda: failures.append(1))
        real = effects.effect

        def missing(_effect_id):
            raise ImportError("No module named 'fx_membrane'")

        effects.effect = missing
        try:
            with self.assertLogs(effect_overlay.LOGGER, "ERROR"):
                overlay.configure("skin", "signal")
        finally:
            effects.effect = real
        self.assertTrue(overlay.failed)
        self.assertEqual(failures, [1])
        overlay.push("right", 0.6, False, QPointF(10, 10))
        self.assertFalse(overlay.player.busy)

    def test_a_switch_with_glow_or_beam_plays_the_locator_where_the_pointer_is(self):
        for style in ("glow", "beam"):
            with self.subTest(style=style):
                overlay = effect_overlay.EffectOverlay()
                overlay.configure(style, "sunset")
                self.assertIs(overlay._fx, effects.LOCATOR)
                overlay.switched(QPointF(300, 200))
                arrival = overlay.player.arrival
                self.assertTrue(arrival["switch"])
                desk = overlay._desk
                self.assertEqual(arrival["at"], (300 - desk.x(), 200 - desk.y()))
                overlay.stop()

    def test_a_switch_with_an_effect_plays_that_effect(self):
        overlay = effect_overlay.EffectOverlay()
        overlay.configure("rupture", "neon")
        overlay.switched(QPointF(300, 200))
        self.assertEqual(overlay._fx.id, "rupture")
        self.assertEqual(overlay.player.arrival["method"], "switch")
        overlay.stop()

    def test_the_app_shows_a_switch_only_with_both_switches_on(self):
        import app_config
        import kvm_bridge_win

        def overlay_for(**change):
            config = replace(app_config.default_config(), glow_style="glow", **change)
            owner = SimpleNamespace(_closing=False, _config=config, effects=None, _on_effects_failed=lambda: None)
            return kvm_bridge_win.WindowsApplication._switch_overlay(owner)

        self.assertIsNotNone(overlay_for())
        self.assertIsNone(overlay_for(shortcut_arrival=False))
        self.assertIsNone(overlay_for(edge_glow=False))

    def test_the_window_margin_stops_at_a_pens_display(self):
        pen = effects.Pen()
        pen.fillRect(100, 100, 50, 50)
        pen.bounds, pen.clip = (100.0, 100.0, 150.0, 150.0), (100.0, 0.0, 400.0, 400.0)
        self.assertEqual(effect_overlay.union_bounds([pen], 2.0), (100.0, 98.0, 152.0, 152.0))

    def test_a_pen_that_names_its_display_is_drawn_inside_it(self):
        pen = effects.Pen()
        pen.fillRect(0, 0, 50, 50)
        pen.clip = (10.0, 20.0, 110.0, 220.0)
        painter = FakePainter()
        effect_overlay.replay(painter, [pen])
        self.assertEqual(painter.clips, [(10.0, 20.0, 100.0, 200.0)])
        self.assertEqual(painter._stack, [])

    def test_each_event_plays_on_the_display_under_the_pointer(self):
        overlay = effect_overlay.EffectOverlay()
        overlay.configure("skin", "signal")
        overlay.arrive("edge", "left", QPointF(10, 10))
        # A 150% display beside a 100% one, as Qt's logical geometry has them.
        overlay._displays = [(0.0, 0.0, 2560.0, 1440.0), (2560.0, 0.0, 1706.0, 960.0)]
        overlay._desk = QRect(0, 0, 4266, 1440)
        overlay.arrive("edge", "left", QPointF(3000, 1300))
        arrival = overlay.player.arrival
        overlay.stop()
        self.assertEqual((arrival["display"], arrival["at"]), ((2560.0, 0.0, 1706.0, 960.0), (3000.0, 959.0)))

    def test_the_event_that_starts_an_effect_draws_its_first_frame(self):
        overlay = effect_overlay.EffectOverlay()
        overlay.configure("rupture", "neon")
        overlay.arrive("edge", "left", QPointF(2, 200))
        drawn = bool(overlay._pens)
        overlay.stop()
        self.assertTrue(drawn)

    def test_a_corner_push_plays_the_corner_form_on_its_display(self):
        overlay = effect_overlay.EffectOverlay()
        overlay.configure("hyperdrive", "neon")
        overlay.push("left", 0.5, False, QPointF(1, 1), part="top_left")
        depart = overlay.player.depart
        overlay.stop()
        self.assertEqual((depart["method"], depart["region"]["kind"], depart["region"]["corner"]),
                         ("corner", "corner", "top_left"))
        self.assertEqual((depart["region"]["w"], depart["region"]["h"]), (8.0, 8.0))

    def test_a_push_ticks_each_quarter_once(self):
        overlay = effect_overlay.EffectOverlay()
        overlay.configure("skin", "signal")
        seen = []
        real_push = overlay.player.push
        overlay.player.push = lambda now, method, region, at, pressure, tick=None, display=None: (
            seen.append(tick), real_push(now, method, region, at, pressure, tick, display))
        for pressure in (0.1, 0.3, 0.3, 0.55, 0.8, 0.9):
            overlay.push("right", pressure, False, QPointF(10, 10))
        overlay.stop()
        self.assertEqual([tick for tick in seen if tick], [1, 2, 3])


if __name__ == "__main__":
    unittest.main()