1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
//! macOS rasteriser for [`crate::primitives::pipeline_view::PipelineView`].
//!
//! Painting moved to the shared
//! [`crate::primitives::pipeline_view::native_surface_paint::paint`]
//! (#1085, `PaintSurface` Phase 4 slice 8/8) — see that fn's doc for the
//! seven named divergences found while unifying
//! `gtk::pipeline_view::draw_pipeline_view`,
//! `macos::pipeline_view::draw_pipeline_view` and
//! `win::pipeline_view::draw_pipeline_view` into one implementation. This
//! module now only carries [`mac_pipeline_view_layout`] (still real,
//! backend-specific pure geometry — no painting involved); the
//! deprecated `draw_pipeline_view` compatibility shim over the shared
//! [`super::surface::CgSurface`] adapter was removed in issue #1109
//! (zero uses in coord-tui's `main` and vimcode's `develop`).
#[cfg(test)]
use core_text::font::CTFont;
use crate::primitives::layout_metrics::pixel_pipeline_view_layout;
use crate::primitives::pipeline_view::{PipelineView, PipelineViewLayout};
#[cfg(test)]
use crate::theme::Theme;
/// Compute the macOS pixel-unit layout for a [`PipelineView`]. Shares its
/// geometry with `gtk_pipeline_view_layout` / `win_pipeline_view_layout`
/// via [`pixel_pipeline_view_layout`] (issue #1079).
pub fn mac_pipeline_view_layout(
view: &PipelineView,
x: f64,
y: f64,
w: f64,
h: f64,
) -> PipelineViewLayout {
pixel_pipeline_view_layout(view, x as f32, y as f32, w as f32, h as f32)
}
#[cfg(test)]
mod tests {
use super::super::headless::BitmapSurface;
use super::super::text::make_font;
use super::super::MacBackend;
use super::*;
use crate::event::{Rect as QRect, Viewport};
use crate::primitives::pipeline_view::{PipelineHit, PipelineStage, StageStatus};
use crate::types::WidgetId;
use crate::Backend;
const W: u32 = 300;
const H: u32 = 80;
fn font() -> CTFont {
make_font("Menlo", 14.0).expect("Menlo installed")
}
fn make_view() -> PipelineView {
PipelineView {
id: WidgetId::new("pipe"),
stages: vec![
PipelineStage {
label: "Build".into(),
status: StageStatus::Done,
action: None,
},
PipelineStage {
label: "Test".into(),
status: StageStatus::Active,
action: Some("Retry".into()),
},
],
focused_stage: None,
}
}
/// Paint via the real `Backend::draw_pipeline_view` path — which now
/// routes through the shared `native_surface_paint::paint` — avoids
/// tripping the `-D warnings`-denied `deprecated` lint (CLAUDE.md
/// rule 3) by not calling the deprecated free-function shim above.
fn paint_via_backend(view: &PipelineView) -> (BitmapSurface, PipelineViewLayout) {
let surface = BitmapSurface::new(W, H);
surface.fill(0.0, 0.0, 0.0, 0.0);
let mut backend = MacBackend::new();
backend.set_current_font(font());
backend.begin_frame(Viewport::new(W as f32, H as f32, 1.0));
let layout = std::cell::RefCell::new(None);
backend.enter_frame_scope(surface.context_ptr(), |b| {
let l = b.draw_pipeline_view(QRect::new(0.0, 0.0, W as f32, H as f32), view);
*layout.borrow_mut() = Some(l);
});
backend.end_frame();
(surface, layout.into_inner().unwrap())
}
#[test]
fn draws_without_panic_and_has_two_stages() {
let view = make_view();
let (_surface, layout) = paint_via_backend(&view);
assert_eq!(layout.stages.len(), 2);
}
/// Regression for #1085 divergence 4: macOS previously painted no
/// tint at all behind the action button — this fixture's stage 1
/// ("Test") has an action, so its `action_bounds` must now show a
/// visible `accent_bg` tint rather than the plain box background.
#[test]
fn action_button_paints_a_translucent_accent_tint() {
let view = make_view();
let (surface, layout) = paint_via_backend(&view);
let ab = layout.stages[1]
.action_bounds
.expect("stage 1 has an action button");
// Probe near the tint's edge, clear of the button's own glyphs.
let px = (ab.x + 2.0) as u32;
let py = (ab.y + ab.height - 2.0) as u32;
let (r, g, b, _a) = surface.pixel(px, py);
assert_ne!(
(r, g, b),
(0, 0, 0),
"action button area must show the accent tint, not the plain (black) box fill",
);
}
/// Regression for #1085 divergence 5: the action-button label used to
/// paint flush to `ab.y` on macOS (ignoring the button's own height);
/// it now centres like GTK/Windows, so the glyph ink should not touch
/// the very top row of `action_bounds`.
#[test]
fn action_button_label_is_vertically_centred() {
let view = make_view();
let (surface, layout) = paint_via_backend(&view);
let ab = layout.stages[1]
.action_bounds
.expect("stage 1 has an action button");
// The top-most row of the action strip should be clear of glyph
// ink (just the translucent tint) once the label is centred
// rather than flush to the top.
let mut top_row_has_dark_glyph_ink = false;
for x in (ab.x as u32)..(ab.x + ab.width) as u32 {
let (r, g, b, _) = surface.pixel(x, ab.y as u32);
// Glyph ink here is painted in `accent_bg`; the tint alone is
// a much darker blend toward the black background. Look for
// a near-pure accent_bg pixel specifically at the top row.
let theme = Theme::default();
if (r, g, b) == (theme.accent_bg.r, theme.accent_bg.g, theme.accent_bg.b) {
top_row_has_dark_glyph_ink = true;
}
}
assert!(
!top_row_has_dark_glyph_ink,
"action label should be vertically centred in its button, not flush to the top row",
);
}
/// Shared body for the action↔click round trip, run at both the
/// origin and a non-zero origin (quadraui#494 / LESSONS.md "Layout
/// helpers must return coords in the same frame across backends").
/// `mac_pipeline_view_layout` bakes `x`/`y` straight into the
/// returned bounds (absolute frame, matching the GTK/TUI twins) —
/// and *also* adds
/// [`crate::primitives::layout_metrics::pixel::PIPELINE_FOCUS_INDICATOR_H`]
/// to `y` itself before laying out, an extra reason a non-zero-origin
/// regression is plausible here. Deriving `ab`/`bb` from the layout
/// (not hardcoding them) means this exercises whatever origin math
/// the function actually does, at any origin. Calls
/// `mac_pipeline_view_layout` directly (pure fn, no font/paint
/// dependency — it forwards to `PipelineView::layout`, which is
/// plain geometry).
fn layout_hit_test_action_round_trip_at(origin_x: f64, origin_y: f64) {
let view = make_view();
let layout = mac_pipeline_view_layout(&view, origin_x, origin_y, 300.0, 80.0);
// Box top must sit exactly at origin_y + PIPELINE_FOCUS_INDICATOR_H,
// not a hardcoded absolute value — pins the offset math
// independently of the hit_test round trip below.
let bb0 = layout.stages[0].box_bounds;
assert!(
(bb0.y as f64
- (origin_y
+ (crate::primitives::layout_metrics::pixel::PIPELINE_FOCUS_INDICATOR_H
as f64)))
.abs()
< 0.001,
"stage box top should be origin_y + PIPELINE_FOCUS_INDICATOR_H, got {}",
bb0.y,
);
// Stage 1 has action bounds.
let ab = layout.stages[1]
.action_bounds
.expect("action bounds for stage 1");
let hit = layout.hit_test(ab.x + ab.width / 2.0, ab.y + ab.height / 2.0);
assert_eq!(hit, PipelineHit::Action(1));
}
#[test]
fn layout_hit_test_action_round_trip() {
layout_hit_test_action_round_trip_at(0.0, 0.0);
}
/// Non-zero-origin regression guard (quadraui#494).
#[test]
fn layout_hit_test_action_round_trip_at_nonzero_origin() {
layout_hit_test_action_round_trip_at(7.0, 13.0);
}
fn layout_hit_test_body_round_trip_at(origin_x: f64, origin_y: f64) {
let view = make_view();
let layout = mac_pipeline_view_layout(&view, origin_x, origin_y, 300.0, 80.0);
let bb = layout.stages[0].box_bounds;
assert!(
(bb.y as f64
- (origin_y
+ (crate::primitives::layout_metrics::pixel::PIPELINE_FOCUS_INDICATOR_H
as f64)))
.abs()
< 0.001,
"stage box top should be origin_y + PIPELINE_FOCUS_INDICATOR_H, got {}",
bb.y,
);
// Stage 0 has no action, so a click inside its box resolves to Body.
let hit = layout.hit_test(bb.x + 1.0, bb.y + 1.0);
assert_eq!(hit, PipelineHit::Body(0));
}
#[test]
fn layout_hit_test_body_round_trip() {
layout_hit_test_body_round_trip_at(0.0, 0.0);
}
/// Non-zero-origin regression guard (quadraui#494).
#[test]
fn layout_hit_test_body_round_trip_at_nonzero_origin() {
layout_hit_test_body_round_trip_at(7.0, 13.0);
}
}