diff --git a/docs/reference/sheet.md b/docs/reference/sheet.md index ed2129d5..e48b9460 100644 --- a/docs/reference/sheet.md +++ b/docs/reference/sheet.md @@ -369,7 +369,7 @@ for a Y-axis end-on feature. The solve may report the requested side unplaceable does not silently switch sides. Dimension-side overrides currently cover native hole/pattern callouts, step/boss diameter -leaders, pocket depth leaders, and envelope height; +leaders, pocket depth leaders, slot widths/lengths, and envelope height; unsupported renderers are not advertised as movable. The side surface accepts `above`, `below`, `left`, and `right` where the selected renderer supports them; `validate_layout_override()` returns diff --git a/src/draftwright/annotations/_slots.py b/src/draftwright/annotations/_slots.py index e1d67091..d6dcd3c4 100644 --- a/src/draftwright/annotations/_slots.py +++ b/src/draftwright/annotations/_slots.py @@ -202,6 +202,37 @@ def _record_slot_drop( ) +def _slot_dimension_side_choices(approved, meas_axis, h_axis, zones, h_proj, v_proj): + """Return measured/perpendicular projections and two bounded side choices.""" + if meas_axis == h_axis: + meas_proj, perp_proj = h_proj, v_proj + sides = (("above", zones.above, True), ("below", zones.below, False)) + else: + meas_proj, perp_proj = v_proj, h_proj + sides = (("right", zones.right, True), ("left", zones.left, False)) + if approved.side is not None: + selected = next((choice for choice in sides if choice[0] == approved.side), None) + if selected is None: + raise ValueError(f"unsupported slot dimension side {approved.side!r}") + sides = (selected, (selected[0], None, selected[2])) + return meas_proj, perp_proj, sides + + +def _slot_shared_width_key(slot, approved, views, draft): + """Do not coalesce equal widths with different explicit side policies.""" + half_width = slot.width / 2 + slot_view = views[frozenset((slot.width_axis, slot.long_axis))] + return ( + "slot_size", + slot_view[0], + slot.width_axis, + round(slot.w_center - half_width, 3), + round(slot.w_center + half_width, 3), + approved.value_text + _tol_suffix(approved.tolerance, draft), + approved.side, + ) + + def _place_slot_dimension( dwg, ctx, @@ -245,12 +276,7 @@ def _place_slot_dimension( p_lo, p_hi = mid - sgn * disp / 2, mid + sgn * disp / 2 else: p_hi = p_lo + sgn * disp - if meas_axis == ha: - meas_proj, perp_proj = hp, vp - sides = (("above", zn.above, True), ("below", zn.below, False)) - else: - meas_proj, perp_proj = vp, hp - sides = (("right", zn.right, True), ("left", zn.left, False)) + meas_proj, perp_proj, sides = _slot_dimension_side_choices(approved, meas_axis, ha, zn, hp, vp) prefix = s.kind if s.kind in ("pad", "pocket") else "slot" cname = f"m_{prefix}{idx}_{kind}" @@ -467,16 +493,7 @@ def _render_slot_dimensions(dwg, plan, a: Analysis, *, ctx, only=None, reach) -> # corridor solve. Matching displayed text alone would merge unequal sizes that # happen to round alike; matching geometry alone would merge distinct tolerances. def _shared_width_key(slot, approved): - half_width = slot.width / 2 - slot_view = views[frozenset((slot.width_axis, slot.long_axis))] - return ( - "slot_size", - slot_view[0], - slot.width_axis, - round(slot.w_center - half_width, 3), - round(slot.w_center + half_width, 3), - approved.value_text + _tol_suffix(approved.tolerance, draft), - ) + return _slot_shared_width_key(slot, approved, views, draft) shared_widths: dict[tuple, list] = {} for group in slot_groups: diff --git a/src/draftwright/model/planner.py b/src/draftwright/model/planner.py index c889e7ef..70e8dfd5 100644 --- a/src/draftwright/model/planner.py +++ b/src/draftwright/model/planner.py @@ -1857,6 +1857,48 @@ def _validate_compound_callout_side(feature, approved, selected_view, requested_ ) +def _validate_slot_dimension_sides(feature: SlotFeature, approved: list[PlannedDimension]) -> None: + """Slot linear marks each own their end-on-view corridor.""" + horizontal_axis = "y" if _plane_normal(feature) == "x" else "x" + for pd in approved: + if pd.view is not None and pd.view not in _parameter_view_preferences(feature, pd): + raise ValueError( + f"slot dimension {pd.param.parameter_id!r} cannot render in {pd.view!r}" + ) + if pd.side is None: + continue + measured_axis = feature.width_axis if pd.param.role == "slot_width" else feature.long_axis + supported = ( + ({"above", "below"} if measured_axis == horizontal_axis else {"left", "right"}) + if pd.param.role in {"slot_width", "slot_length"} + else set() + ) + if pd.side not in supported: + raise ValueError( + f"slot dimension {pd.param.parameter_id!r} cannot render on {pd.side!r}; " + f"supported sides: {sorted(supported) or 'none'}" + ) + + +def _validate_envelope_dimension_sides(feature, approved) -> None: + """Envelope extents scatter independently across their planned views.""" + for pd in approved: + supported_sides = {"left", "right"} if pd.param.role == "height" else set() + if pd.side is not None and pd.side not in supported_sides: + raise ValueError( + f"envelope dimensions cannot render at {pd.view!r}/{pd.side!r}; " + f"supported sides for this renderer: {sorted(supported_sides) or 'none'}" + ) + if pd.view is None: + continue + eligible_views = _parameter_view_preferences(feature, pd) + if pd.view not in eligible_views: + raise ValueError( + f"envelope dimension {pd.param.parameter_id!r} cannot render in " + f"{pd.view!r}; supported view(s): {list(eligible_views)}" + ) + + def _group_placement(feature: Feature, dims: list[PlannedDimension], planned_views=None): """Resolve one view/side for a compound group, or reject an unrenderable intent.""" approved = [pd for pd in dims if not pd.suppressed] @@ -1884,21 +1926,14 @@ def _group_placement(feature: Feature, dims: list[PlannedDimension], planned_vie # on the PlannedDimension; forcing them through the one-callout policy below would # reject a perfectly valid width/front + depth/side pair. if feature.kind == "envelope": - for pd in approved: - supported_sides = {"left", "right"} if pd.param.role == "height" else set() - if pd.side is not None and pd.side not in supported_sides: - raise ValueError( - f"envelope dimensions cannot render at {pd.view!r}/{pd.side!r}; " - f"supported sides for this renderer: {sorted(supported_sides) or 'none'}" - ) - if pd.view is None: - continue - eligible_views = _parameter_view_preferences(feature, pd) - if pd.view not in eligible_views: - raise ValueError( - f"envelope dimension {pd.param.parameter_id!r} cannot render in " - f"{pd.view!r}; supported view(s): {list(eligible_views)}" - ) + _validate_envelope_dimension_sides(feature, approved) + return _group_view(feature, planned_views), None + + # Slot widths and lengths are separate linear marks, not one compound leader. + # Validate each side against its measured axis in the end-on view so a width + # and a length can be moved independently without coupling their policies. + if isinstance(feature, SlotFeature): + _validate_slot_dimension_sides(feature, approved) return _group_view(feature, planned_views), None unsupported_pattern_intents = [ diff --git a/src/draftwright/sheet_layout_controls.py b/src/draftwright/sheet_layout_controls.py index d3353839..946eee14 100644 --- a/src/draftwright/sheet_layout_controls.py +++ b/src/draftwright/sheet_layout_controls.py @@ -114,7 +114,7 @@ def layout_options( } # Only advertise sides whose renderer consumes the authored corridor. Other # planner-accepted sides are not an editor actuator until that renderer uses them. - if feature.kind in {"hole", "pattern", "envelope", "step", "boss", "pocket"}: + if feature.kind in {"hole", "pattern", "envelope", "step", "boss", "pocket", "slot"}: placements = sheet.dimension_options(handle, parameter)["placements"] sides = sorted( { diff --git a/tests/_function_length_baseline.json b/tests/_function_length_baseline.json index 3a769823..47f62071 100644 --- a/tests/_function_length_baseline.json +++ b/tests/_function_length_baseline.json @@ -7,8 +7,7 @@ "annotations/_locations.py:render_locations": 258, "annotations/_pmi_dimensions.py:_place_pmi_record": 258, "annotations/_pmi_dimensions.py:_sheet_leader_fallback": 240, - "annotations/_slots.py:_place_slot_dimension": 218, - "annotations/_slots.py:_render_slot_dimensions": 204, + "annotations/_slots.py:_place_slot_dimension": 213, "annotations/_step_lengths.py:_render_profile_groups": 207, "annotations/_step_lengths.py:_render_y_profile": 228, "annotations/balloons.py:render_balloons": 294, diff --git a/tests/test_layout_override_lane_issue_1757.py b/tests/test_layout_override_lane_issue_1757.py index dcb61429..72f72098 100644 --- a/tests/test_layout_override_lane_issue_1757.py +++ b/tests/test_layout_override_lane_issue_1757.py @@ -55,7 +55,8 @@ def test_lane_capability_targets_one_declared_parameter() -> None: "minimum": 1, "maximum": 8, "meaning": "one-based drafting-spaced lane from the feature witness", - } + }, + "side": {"current": None, "supported_values": ["left", "right"]}, }, } assert ( @@ -65,9 +66,9 @@ def test_lane_capability_targets_one_declared_parameter() -> None: is True ) unsupported_side = sheet.validate_layout_override( - "declaration:slot", parameter="slot_width.length", side="left" + "declaration:slot", parameter="slot_width.length", side="above" ) - assert unsupported_side["issues"][0]["code"] == "unsupported_control" + assert unsupported_side["issues"][0]["code"] == "unsupported_value" missing_parameter = sheet.validate_layout_override("declaration:slot", lane=4) assert missing_parameter["issues"][0]["code"] == "invalid_control_combination" @@ -356,6 +357,63 @@ def test_pocket_width_does_not_advertise_depth_leader_side() -> None: assert result["supported"] is False +@pytest.mark.parametrize( + ("parameter", "sides", "unsupported"), + [ + ("slot_width.length", ("left", "right"), "above"), + ("slot_length.length", ("above", "below"), "right"), + ], +) +def test_slot_dimension_side_override_uses_its_own_measured_axis( + parameter, sides, unsupported +) -> None: + for side in sides: + sheet = _slot_sheet() + options = sheet.layout_options("declaration:slot", parameter=parameter) + assert options["controls"]["side"]["supported_values"] == sorted(sides) + sheet.layout_override("declaration:slot", parameter=parameter, side=side) + drawing = sheet.build() + kind = "width" if parameter.startswith("slot_width") else "length" + mark = drawing.get_annotation(f"m_slot0_{kind}") + assert mark is not None + assert mark.placement_spec.side == side + assert not _slot_sheet().validate_layout_override( + "declaration:slot", parameter=parameter, side=unsupported + )["supported"] + + +def test_slot_width_and_length_sides_are_independent() -> None: + sheet = _slot_sheet() + sheet.layout_override("declaration:slot", parameter="slot_width.length", side="left") + sheet.layout_override("declaration:slot", parameter="slot_length.length", side="below") + drawing = sheet.build() + assert drawing.get_annotation("m_slot0_width").placement_spec.side == "left" + assert drawing.get_annotation("m_slot0_length").placement_spec.side == "below" + + +@pytest.mark.parametrize("width_axis", ["x", "y"]) +def test_upright_slot_side_options_follow_projected_axes(width_axis) -> None: + sheet = Sheet(Box(100, 100, 100)).authored_dimensions() + slot = sheet.slot( + width=20, + length=40, + long_axis="z", + width_axis=width_axis, + lo=-20, + hi=20, + w_center=0, + at=(0, 0, 0), + ).identify("declaration:slot") + sheet.dimension(slot, "slot_width.length") + sheet.dimension(slot, "slot_length.length") + assert sheet.layout_options("declaration:slot", parameter="slot_width.length")["controls"][ + "side" + ]["supported_values"] == ["above", "below"] + assert sheet.layout_options("declaration:slot", parameter="slot_length.length")["controls"][ + "side" + ]["supported_values"] == ["left", "right"] + + def test_lane_override_changes_only_the_exact_dimension_policy() -> None: sheet = _slot_sheet() sheet.layout_override("declaration:slot", parameter="slot_width.length", lane=4)