One keyboard and mouse for a Mac and a Windows PC over the local network, in either direction.
"""Map third hit bands and ledger segments share the saved third choice."""
import copy
import itertools
import sys
from pathlib import Path
from unittest import mock
sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
sys.path.insert(0, str(Path(__file__).resolve().parent))
import AppKit
import Quartz
AppKit.NSApplication.sharedApplication()
import diagram
import theme
from core import return_edge, ways
from test_crossing_page_machines import BEE, SEA, Page, press, token
class PartEdgeThirds(Page):
def layout(self, side="right", scoped=False, second=False):
peers = [(BEE, token(100), "Bee", {"side": side})]
zones = [{"peer": BEE, "kind": "edge"}]
if scoped:
zones.append({"peer": BEE, "kind": "edge", "display": "main", "side": side,
"target_side": return_edge.OPPOSITE[side]})
if second:
peers.append((SEA, token(150), "Sea", {"side": "left"}))
zones.append({"peer": SEA, "kind": "edge"})
window = self.build(peers, zones)
own = self.store.current()["machine_id"]
x, y = {"right": (160, 0), "left": (-160, 0), "top": (0, -90), "bottom": (0, 90)}[side]
tiles = {own: {"x": 0, "y": 0, "w": 160, "h": 90},
BEE: {"x": x, "y": y, "w": 160, "h": 90}}
if scoped:
for tile in tiles.values():
tile["displays"] = {"main": {"x": 0, "y": 0, "w": 160, "h": 90}}
if second:
tiles[SEA] = {"x": -160, "y": 0, "w": 160, "h": 90}
window._atlas_layout_changed(tiles, BEE, snap=False)
self.pick(BEE)
canvas = window.atlas_canvas
canvas.setFrame_(((0, 0), (480, canvas.HEIGHT)))
canvas._draw(False)
return window
def row(self):
return self.window.crossing_ledger.rows[BEE]
def picked(self):
return [part for part, button in self.row().contact().segments.items()
if button.accessibilityValue() == "on"]
def pick_thirds(self, picked):
self.whole_edge()
for part in ways.PARTS:
if part not in picked:
press(self.row().contact().segments[part])
def whole_edge(self):
if self.picked():
press(self.row().contact())
press(self.row().contact())
def third_point(self, third, offset=0, peer=BEE):
canvas = self.window.atlas_canvas
own = canvas.tiles[canvas.own_id]
contact = ways._rect_contact(own, canvas.tiles[peer])
frames, scale = canvas._map()
frame = frames[canvas.own_id]
_third, side, low, high = next(stretch for stretch in ways.third_stretches(contact, own)
if stretch[0] == third)
if side in ("left", "right"):
return AppKit.NSMakePoint(frame[0] + (frame[2] if side == "right" else 0) + offset,
frame[1] + ((low + high) / 2 - own["y"]) * scale)
return AppKit.NSMakePoint(frame[0] + ((low + high) / 2 - own["x"]) * scale,
frame[1] + (frame[3] if side == "bottom" else 0) + offset)
def click_third(self, third, offset=0):
canvas = self.window.atlas_canvas
point = self.third_point(third, offset)
event = mock.Mock()
event.locationInWindow.return_value = point
event.clickCount.return_value = 1
event.modifierFlags.return_value = 0
with mock.patch.object(canvas, "window"), \
mock.patch.object(canvas, "convertPoint_fromView_", return_value=point), \
mock.patch.object(diagram.AppKit, "NSCursor"):
canvas.mouseDown_(event)
self.assertIsNone(canvas.dragging)
canvas.mouseUp_(event)
def test_all_seven_choices_round_trip_ledger_saved_intent_and_map(self):
window = self.layout()
row = self.row()
buttons = dict(row.contact().segments)
for count in (1, 2, 3):
for picked in itertools.combinations(ways.PARTS, count):
with self.subTest(picked=picked):
self.pick_thirds(picked)
saved = self.ways_of(BEE)
self.assertEqual(ways.picked_thirds(saved["methods"], saved["parts"]), list(picked))
window._load_ways()
window._reflect()
window.atlas_canvas._draw(False)
self.assertEqual(self.picked(), list(picked))
self.assertEqual(window.atlas_canvas.states[BEE]["picked_thirds"], list(picked))
self.assertIs(self.row(), row)
for part, button in buttons.items():
self.assertIs(row.contact().segments[part], button)
def test_map_clicks_each_third_on_each_side_and_ledger_follows(self):
for side in ways.EDGES:
self.layout(side)
for third in ways.PARTS:
with self.subTest(side=side, third=third):
self.whole_edge()
self.click_third(third, offset=4)
self.assertEqual(self.picked(), [part for part in ways.PARTS if part != third])
self.click_third(third, offset=-4)
self.assertEqual(self.picked(), list(ways.PARTS))
def test_last_third_off_then_map_reopens_only_the_clicked_third(self):
self.layout()
self.pick_thirds(["start"])
self.click_third("start")
self.assertEqual(self.picked(), [])
self.assertFalse(set(self.ways_of(BEE)["methods"]) & {"edge", "part"})
self.click_third("end")
self.assertEqual(self.picked(), ["end"])
self.assertEqual(self.ways_of(BEE)["parts"], ["end"])
self.whole_edge()
self.assertEqual(self.picked(), list(ways.PARTS))
def test_mouse_down_and_drag_wait_for_mouse_up_and_never_move_tiles(self):
window = self.layout()
canvas = window.atlas_canvas
before = copy.deepcopy(canvas.tiles)
point = self.third_point("middle")
event = mock.Mock()
event.locationInWindow.return_value = point
with mock.patch.object(canvas, "window"), \
mock.patch.object(canvas, "convertPoint_fromView_", return_value=point):
canvas.mouseDown_(event)
canvas.mouseDragged_(event)
self.assertIsNone(canvas.dragging)
self.assertEqual(canvas.tiles, before)
self.assertEqual(self.picked(), list(ways.PARTS))
canvas.mouseUp_(event)
self.assertEqual(self.picked(), ["start", "end"])
self.assertEqual(canvas.tiles, before)
def test_releasing_in_another_third_cancels(self):
self.layout()
canvas = self.window.atlas_canvas
with mock.patch.object(canvas, "window"), \
mock.patch.object(canvas, "convertPoint_fromView_", side_effect=[
self.third_point("start"), self.third_point("end")]):
canvas.mouseDown_(mock.Mock())
canvas.mouseUp_(mock.Mock())
self.assertEqual(self.picked(), list(ways.PARTS))
self.assertIsNone(canvas.third_pressed)
def test_tooltips_cursor_and_five_pixel_band(self):
self.layout()
canvas = self.window.atlas_canvas
self.assertEqual(canvas._third_tooltip(BEE, "start"), "Top third: click to turn it off")
self.pick_thirds(["start"])
self.assertEqual(canvas._third_tooltip(BEE, "start"), "Top third: click to turn it off")
self.assertEqual(canvas._third_tooltip(BEE, "end"), "Bottom third: click to turn it on")
point = self.third_point("end", 5)
self.assertEqual(canvas._third_hit(point), (BEE, "end"))
self.assertIsNone(canvas._third_hit(self.third_point("end", 5.1)))
with mock.patch.object(canvas, "convertPoint_fromView_", return_value=point), \
mock.patch.object(diagram.AppKit, "NSCursor") as cursor:
canvas.mouseMoved_(mock.Mock())
cursor.pointingHandCursor.return_value.set.assert_called_once()
def test_selected_tracks_breaks_and_other_peers_seam(self):
window = self.layout(second=True)
self.pick_thirds(["middle"])
canvas = window.atlas_canvas
canvas._draw(False)
self.assertEqual(set(canvas.third_layers), {(BEE, "start", "track"), (BEE, "end", "track")})
track = canvas.third_layers[(BEE, "start", "track")]
self.assertEqual(track.lineWidth(), 2)
self.assertAlmostEqual(track.opacity(), .3)
self.assertEqual(track.lineCap(), Quartz.kCALineCapRound)
self.assertTrue(Quartz.CGColorEqualToColor(track.strokeColor(), theme.cg("signal")))
x, y, _width, height = canvas._map()[0][canvas.own_id]
seam = [segment for segment in canvas.seam_segments if segment["peer"] == BEE]
self.assertEqual([segment["kind"] for segment in sorted(seam, key=lambda s: s["start"][1])],
["track", "seam", "track"])
for segment in seam:
self.assertEqual(segment["start"][0], segment["end"][0])
ends = sorted(seam, key=lambda s: s["start"][1])
for before, after, point in zip(ends, ends[1:], (y + height / 3, y + 2 * height / 3)):
seen_end, seen_start = before["end"][1] + before["width"] / 2, after["start"][1] - after["width"] / 2
self.assertAlmostEqual((seen_end + seen_start) / 2, point)
self.assertAlmostEqual(seen_start - seen_end, diagram.THIRD_GAP)
self.assertIn((canvas.own_id, SEA, "signal"), canvas.contact_layers)
self.assertIsNone(canvas._third_hit(self.third_point("start", peer=SEA)))
self.pick(SEA)
canvas._draw(False)
self.assertFalse(any(key[0] == BEE for key in canvas.third_layers))
def test_picked_third_with_only_a_sliver_of_contact_is_not_lit(self):
window = self.layout()
window.windows_input.server.caps_of.return_value = ["layout"]
self.pick_thirds(["start", "middle"])
tiles = copy.deepcopy(self.store.current()["layout"])
tiles[BEE].update(y=25, h=40)
settings = self.store.current()
settings["layout"] = tiles
self.store.save_settings(settings)
window._show_arrangement()
canvas = window.atlas_canvas
canvas._draw(False)
self.assertEqual(canvas.states[BEE]["picked_thirds"], ["start", "middle"])
self.assertEqual(canvas.states[BEE]["lit_thirds"], ["middle"])
self.assertIn((BEE, "start", "track"), canvas.third_layers)
def test_edge_off_survives_layout_compile_and_text_restores_whole(self):
for scoped in (False, True):
with self.subTest(scoped=scoped):
window = self.layout(scoped=scoped)
self.pick_thirds(["start", "end"])
press(self.row().contact())
window._atlas_layout_changed(copy.deepcopy(self.store.current()["layout"]), BEE, snap=False)
self.assertFalse(set(self.ways_of(BEE)["methods"]) & {"edge", "part"})
self.assertEqual(self.picked(), [])
window.atlas_canvas._draw(False)
self.assertFalse(any(key[-1] == "track" for key in window.atlas_canvas.third_layers))
press(self.row().contact())
self.assertEqual(self.picked(), list(ways.PARTS))
self.assertEqual(self.ways_of(BEE)["methods"], ["edge"])