One keyboard and mouse for a Mac and a Windows PC over the local network, in either direction.
"""The corrected 1.5 layout contract, exercised without ordering a window."""
import unittest
from mac_app.tests.design_offscreen import AppKit, kvm_bridge_app, offscreen_control_window, settle
widgets = kvm_bridge_app.widgets
WIDTHS = (320, 426, 512, 640, 720, 900, 1100, 1440, 1920)
def walk(view):
yield view
if isinstance(view, (AppKit.NSTextField, AppKit.NSButton)):
return
for child in view.subviews():
if not child.isHidden():
yield from walk(child)
def frame_in(view, parent):
rect = view.alignmentRectForFrame_(view.bounds()) if isinstance(view, AppKit.NSTextField) else view.bounds()
return view.convertRect_toView_(rect, parent)
class SettingsLayoutAcceptanceTests(unittest.TestCase):
@classmethod
def setUpClass(cls):
kvm_bridge_app.theme.init_fonts()
cls.control = offscreen_control_window()
def test_capped_profile_buttons_do_not_narrow_the_ledger_when_stacked(self):
control = self.control
control._select_page("crossing")
for width in (320, 426, 512, 900, 426):
control.window.setFrame_display_(((100000, 100000), (width, 900)), False)
settle(control.window)
body = control.pages["crossing"].documentView().subviews()[0]
module = control.ways_ledger_module.view
with self.subTest(width=width):
self.assertAlmostEqual(module.frame().size.width, body.frame().size.width, delta=1)
self.assertFalse(module.hasAmbiguousLayout())
self.assertLessEqual(control.own_ways_button.view.frame().size.width, 240 + 1)
self.assertFalse(control.window.isVisible())
def test_all_six_pages_share_the_centred_column_at_every_width_and_density(self):
from mac_app.tests.settings_layout_offscreen import render
control = self.control
for density in (1, 2):
for width in WIDTHS:
sidebar = 56 if width < 640 else 144 if width < 800 else 176
viewport = width - sidebar - 1 - 16
expected = min(880, viewport - 48)
for key, scroll in control.pages.items():
with self.subTest(page=key, width=width, density=density):
control.window.setFrame_display_(((100000, 100000), (width, 900)), False)
control._select_page(key)
settle(control.window)
self.assertFalse(control.window.isVisible())
self.assertAlmostEqual(control.window.frame().size.width, width, delta=1)
self.assertAlmostEqual(control.sidebar.view.frame().size.width, sidebar, delta=1)
page = scroll.documentView()
body = page.subviews()[0]
self.assertAlmostEqual(body.frame().size.width, expected, delta=1)
self.assertAlmostEqual(body.frame().origin.x, (viewport - expected) / 2, delta=1)
for section in body.arrangedSubviews():
if section.isHidden():
continue
rect = frame_in(section, body)
self.assertAlmostEqual(rect.origin.x, 0, delta=1)
self.assertAlmostEqual(rect.size.width, expected, delta=1)
self.assertLessEqual(page.frame().size.width, scroll.contentView().bounds().size.width + 1)
self.assertFalse(scroll.hasHorizontalScroller())
bitmap = render(control.window.contentView(), density)
self.assertEqual(bitmap.pixelsWide(), width * density)
self.assertEqual(bitmap.pixelsHigh(), round(control.window.contentView().bounds().size.height * density))
def test_controls_labels_and_children_fit_all_six_pages(self):
control = self.control
for width in WIDTHS:
for key, scroll in control.pages.items():
control.window.setFrame_display_(((100000, 100000), (width, 900)), False)
control._select_page(key)
settle(control.window)
body = scroll.documentView().subviews()[0]
with self.subTest(page=key, width=width):
for child in walk(body):
rect = frame_in(child, body)
self.assertGreaterEqual(rect.origin.x, -.99, type(child).__name__)
self.assertLessEqual(rect.origin.x + rect.size.width, body.bounds().size.width + 1,
type(child).__name__)
selector = getattr(child, 'segmented_owner', None)
if selector is not None:
self.assertLessEqual(child.bounds().size.width, selector.cap + 1)
for _, cell, _ in selector.cells:
self.assertLessEqual(cell.bounds().size.width, 120)
self.assertGreaterEqual(cell.bounds().size.height, 30)
if isinstance(child, AppKit.NSButton) and not isinstance(child, AppKit.NSPopUpButton):
self.assertLessEqual(child.bounds().size.width, 241)
field = getattr(child, 'field_owner', None)
if field is not None and field.caption is not None and body.bounds().size.width >= 560:
self.assertAlmostEqual(frame_in(field.words.view, child).size.width, 180, delta=1)
self.assertLessEqual(field.words.view.bounds().size.height, 20)
def test_families_are_horizontal_equal_tiles_and_wrap_by_column_width(self):
control = self.control
for width in WIDTHS:
control.window.setFrame_display_(((100000, 100000), (width, 900)), False)
control._select_page('design')
settle(control.window)
column = control.pages['design'].documentView().subviews()[0].bounds().size.width
for choices, count, gap in ((control.glow_style_select, 3 if column >= 600 else 2 if column >= 400 else 1, 12),
(control.glow_colour_select, 5 if column >= 600 else 3 if column >= 400 else 2, 8)):
for family in choices.rows:
cells = [tile for _, tile, *_ in getattr(family, 'tiles', getattr(family, 'cells', []))]
frames = [frame_in(cell, family.view) for cell in cells]
with self.subTest(width=width, family=family.values):
self.assertEqual(family.columns, min(count, len(cells)))
for rect in frames:
self.assertAlmostEqual(rect.size.width, frames[0].size.width, delta=1)
self.assertAlmostEqual(rect.size.height, frames[0].size.height, delta=1)
if choices is control.glow_style_select:
self.assertAlmostEqual(rect.size.width / rect.size.height, 152 / 116, delta=.015)
for index in range(1, min(count, len(frames))):
self.assertAlmostEqual(frames[index].origin.y, frames[0].origin.y, delta=1)
self.assertAlmostEqual(frames[index].origin.x - frames[index-1].origin.x,
frames[0].size.width + gap, delta=1)
self.assertEqual(len(control.glow_colour_select.rows[1].cells), 5)
def test_window_minimum_and_resize_constraints_cannot_drive_native_frame(self):
control = self.control
self.assertEqual(tuple(control.window.minSize()), (640, 540))
for key in control.pages:
control._select_page(key)
self.assertLess(control.page_width_constraints[key].priority(), 500)
with self.subTest(page=key):
control.window.setFrame_display_(((100000, 100000), (320, 300)), False)
settle(control.window)
self.assertEqual(tuple(control.window.frame().size), (320, 300))
def test_section_padding_and_ordinary_row_spacing_are_shared(self):
control = self.control
for key, scroll in control.pages.items():
control._select_page(key)
control.window.setFrame_display_(((100000, 100000), (1440, 900)), False)
settle(control.window)
for section in scroll.documentView().subviews()[0].arrangedSubviews():
children = section.subviews()
if len(children) != 1 or not isinstance(children[0], AppKit.NSStackView):
continue
body = children[0]
with self.subTest(page=key):
self.assertEqual(body.spacing(), 12)
self.assertAlmostEqual(body.frame().origin.x, 16, delta=1)
self.assertAlmostEqual(body.frame().origin.y, 16, delta=1)
self.assertAlmostEqual(section.bounds().size.width - body.frame().size.width, 32, delta=1)
self.assertEqual(control.style_module.body.customSpacingAfterView_(control.chosen_box), 12)
def test_machine_section_heading_does_not_split_at_the_minimum_width(self):
control = self.control
control._select_page('overview')
control.window.setFrame_display_(((100000, 100000), (320, 900)), False)
settle(control.window)
heading = control.panel.pair_button.view.superview().arrangedSubviews()[0]
self.assertGreaterEqual(heading.bounds().size.width, heading.attributedStringValue().size().width)
def test_atlas_canvas_tiles_fit_the_narrow_column(self):
control = self.control
control._select_page('crossing')
control.window.setFrame_display_(((100000, 100000), (320, 900)), False)
settle(control.window)
canvas = control.atlas_canvas
canvas.setFrame_(((0, 0), (canvas.superview().bounds().size.width, canvas.HEIGHT)))
frames, _scale = canvas._map()
for rect in frames.values():
self.assertGreaterEqual(rect[0], 0)
self.assertGreaterEqual(rect[1], 0)
self.assertLessEqual(rect[0] + rect[2], canvas.bounds().size.width)
self.assertLessEqual(rect[1] + rect[3], canvas.bounds().size.height)
def test_key_recorders_keep_their_titles_readable_in_the_narrow_column(self):
control = self.control
control.window.setFrame_display_(((100000, 100000), (320, 900)), False)
for key, recorder, label in (('crossing', control.key_recorder, control.key_recorder.key),
('keyboard', control.ignored_recorder, control.ignored_recorder.title)):
control._select_page(key)
settle(control.window)
string = label.view.attributedStringValue()
available = label.view.cell().drawingRectForBounds_(label.view.bounds()).size.width
if string.size().width > available:
self.assertTrue(label.wrap)
full = string.boundingRectWithSize_options_((available, 10000), AppKit.NSStringDrawingUsesLineFragmentOrigin)
self.assertGreaterEqual(label.view.bounds().size.height + 1, full.size.height)
def test_sidebar_selection_and_focus_never_diverge(self):
control = self.control
sidebar = control.sidebar
control.window.keyboard_navigation = False
control.window.makeFirstResponder_(sidebar.rows['keyboard'][1])
sidebar._choose('design')
for _, row, *_ in sidebar.rows.values():
self.assertTrue(row.ring is None or row.ring.isHidden())
for action in (lambda: sidebar.step(1), lambda: sidebar.step(-1),
lambda: control.windowDidBecomeKey_(None)):
action()
selected = [key for key, (_, row, *_) in sidebar.rows.items() if row.accessibilityValue() == 1]
self.assertEqual(selected, [control.page])
rings = [key for key, (_, row, *_) in sidebar.rows.items() if row.ring and not row.ring.isHidden()]
self.assertEqual(rings, [control.page])
def test_normal_frames_are_clamped_and_tiled_frames_are_not_persisted(self):
from unittest import mock
work = AppKit.NSMakeRect(20, 40, 640, 480)
self.assertEqual(kvm_bridge_app.settings_normal_frame(None, work), (20, 40, 640, 480))
self.assertEqual(kvm_bridge_app.settings_normal_frame([1000, -200, 500, 400], work), (160, 40, 500, 400))
self.assertEqual(kvm_bridge_app.settings_normal_frame(['bad'], work), (20, 40, 640, 480))
window = mock.Mock()
window.isVisible.return_value = True
window.isZoomed.return_value = False
window.styleMask.return_value = 0
window.frame.return_value = AppKit.NSMakeRect(30, 50, 500, 400)
window.stringWithSavedFrame.return_value = '30 50 500 400 0 0 640 480'
self.assertEqual(kvm_bridge_app.ordinary_window_frame(window), [30, 50, 500, 400])
window.stringWithSavedFrame.return_value += ' {"tilingState":{}}'
self.assertIsNone(kvm_bridge_app.ordinary_window_frame(window))
window.stringWithSavedFrame.return_value = ''
window.styleMask.return_value = AppKit.NSWindowStyleMaskFullScreen
self.assertIsNone(kvm_bridge_app.ordinary_window_frame(window))
control = self.control
held = list(control._normal_frame)
control._frame_transition = True
with mock.patch.object(kvm_bridge_app, 'ordinary_window_frame') as ordinary:
control._remember_normal_frame()
ordinary.assert_not_called()
self.assertEqual(control._normal_frame, held)
control._frame_transition = False
def test_tab_enters_the_selected_page_and_pointer_input_clears_all_focus(self):
control = self.control
control._select_page('design')
control.window.makeFirstResponder_(control.window)
control.window.selectNextKeyView_(None)
self.assertEqual(control.window.firstResponder(), control.sidebar.rows['design'][1])
slider = control.length_select.focusable_views[0]
self.assertTrue(slider.acceptsFirstResponder())
control.window.makeFirstResponder_(slider)
self.assertIs(control.window.firstResponder(), slider)
control.window.keyboard_navigation = False
control.window.refresh_input_focus()
self.assertFalse(control.window.keyboard_navigation)
def test_length_size_stay_vertical_and_toggle_targets_remain_usable(self):
control = self.control
for width in WIDTHS:
control.window.setFrame_display_(((100000, 100000), (width, 900)), False)
control._select_page('design')
settle(control.window)
module = control.style_module.view
length = frame_in(control.length_select.view, module)
size = frame_in(control.size_select.view, module)
self.assertGreater(abs(length.origin.y - size.origin.y), 30)
for switch in (control.glow_box, control.landing_box, control.haptics_box):
self.assertGreaterEqual(switch.view.bounds().size.height, 30)
def test_rail_targets_and_selected_marks_are_explicit(self):
control = self.control
control.window.setFrame_display_(((100000, 100000), (320, 900)), False)
control._select_page('design')
control.sidebar.set_dots({'overview': 'fault', 'permissions': 'amber'})
settle(control.window)
self.assertTrue(control.sidebar.footer_icon.image().isTemplate())
for _, row, icon, words, _, dot in control.sidebar.rows.values():
self.assertEqual(tuple(row.bounds().size), (44, 36))
self.assertTrue(words.view.isHidden())
self.assertTrue(row.toolTip())
self.assertEqual(tuple(icon.alignmentRectForFrame_(icon.bounds()).size), (18, 18))
if not dot.isHidden():
icon_rect, dot_rect = frame_in(icon, row), frame_in(dot, row)
self.assertGreaterEqual(dot_rect.origin.x, icon_rect.origin.x + 18 + 2)
for choices, value in ((control.glow_style_select, 'flint'), (control.glow_colour_select, 'mono')):
choices.value = value
family = next(row for row in choices.rows if value in row.values)
cells = getattr(family, 'tiles', getattr(family, 'cells', []))
for candidate, cell, *_ in cells:
self.assertEqual(cell.selection_mark.isHidden(), candidate != value)
if value == 'mono':
self.assertEqual(family.ring.inner.borderWidth(), 1)
def test_native_machine_menu_complete_bounds_are_capped(self):
control = self.control
for width in WIDTHS:
control.window.setFrame_display_(((100000, 100000), (width, 900)), False)
control._select_page('design')
settle(control.window)
self.assertLessEqual(control.follow_select.view.bounds().size.width, 320)
def test_pairing_notch_and_switch_states_fit_at_every_width(self):
control = self.control
control.panel.open = True
control.panel.refresh()
control.glow_box.value = True
control.landing_box.value = True
control.has_notch = True
control._place_chosen = True
control.place = 'notch'
control.glow_style_select.value = 'glow'
for mode in ('crossing', 'switch'):
control.style_for_select.value = mode
control._reflect()
for width in WIDTHS:
for key in ('overview', 'design'):
control.window.setFrame_display_(((100000, 100000), (width, 900)), False)
control._select_page(key)
settle(control.window)
body = control.pages[key].documentView().subviews()[0]
with self.subTest(page=key, mode=mode, width=width):
for child in walk(body):
rect = frame_in(child, body)
self.assertGreaterEqual(rect.origin.x, -1, type(child).__name__)
self.assertLessEqual(rect.origin.x + rect.size.width, body.bounds().size.width + 1,
type(child).__name__)
def test_breakpoints_reflow_in_both_directions_without_waiting_for_another_resize(self):
control = self.control
for dark in (False, True):
kvm_bridge_app.theme.set_dark(dark)
widths = (319+1, 519, 520, 521, 638, 639, 640, 641, 767, 768, 769, 770, 798, 799, 800, 801, 839, 840, 841, 842, 1440)
for width in widths + widths[::-1]:
control.window.setFrame_display_(((100000, 100000), (width, 900)), False)
control._select_page('design')
settle(control.window)
column = control.pages['design'].documentView().subviews()[0].bounds().size.width
with self.subTest(dark=dark, width=width):
for family in control.glow_style_select.rows:
self.assertEqual(family.columns, 3 if column >= 600 else 2 if column >= 400 else 1)
if column < 560:
self.assertTrue(control.length_row.field_owner.stacked)
elif column >= 576:
self.assertFalse(control.length_row.field_owner.stacked)
self.assertEqual(control.sidebar.rows['design'][3].view.isHidden(), width < 640)
def test_design_rows_stay_stacked_through_the_sidebar_width_change(self):
control = offscreen_control_window()
control._select_page("design")
settle(control.window)
for width, stacked in ((760, True), (780, True), (800, True), (820, False),
(800, True), (780, True), (760, True)):
control.window.setFrame_display_(((100000, 100000), (width, 900)), False)
settle(control.window)
self.assertAlmostEqual(control.window.frame().size.width, width, delta=.5)
self.assertFalse(control.window.isVisible())
for name, row in (("Length", control.length_row), ("Size", control.size_row)):
owner = row.field_owner
self.assertEqual(owner.stacked, stacked, f"{name} at window width {width}")
frame = owner.control.frame()
self.assertGreater(frame.size.width, 0)
self.assertGreaterEqual(frame.origin.x, -.5)
self.assertLessEqual(frame.origin.x + frame.size.width, row.bounds().size.width + 1)
def test_long_buttons_grow_in_height_and_machine_names_remain_available(self):
button = widgets.Button('A longer action whose full label needs several lines in this column', None, None)
host = widgets.box()
host.setFrame_(((0, 0), (180, 200)))
host.addSubview_(button.view)
AppKit.NSLayoutConstraint.activateConstraints_([
button.view.leadingAnchor().constraintEqualToAnchor_(host.leadingAnchor()),
button.view.topAnchor().constraintEqualToAnchor_(host.topAnchor()),
button.view.widthAnchor().constraintEqualToConstant_(180),
])
host.layoutSubtreeIfNeeded()
ink = button.view.attributedTitle().boundingRectWithSize_options_(
(156, 10000), AppKit.NSStringDrawingUsesLineFragmentOrigin)
self.assertGreater(ink.size.height, 30)
self.assertGreaterEqual(button.view.bounds().size.height, ink.size.height + 12)
name = 'A very long machine name kept in full in the native menu'
menu = widgets.MenuChoice([(None, 'None'), ('synthetic', name)])
menu.value = 'synthetic'
self.assertEqual(menu.items[1][1].title(), name)
self.assertEqual(menu.popup.accessibilityValue(), name)
if __name__ == '__main__':
unittest.main()