a
b
"), "a\nb"); + assert_eq!(html_to_plain("ab"), "a\nb"); + assert_eq!(html_to_plain("&<>"' "), "&<>\"' "); + // Unknown entities and bare `&` survive untouched. + assert_eq!(html_to_plain("a &b"), "a &b"); + // A decoded `<p>` is text, never rescanned into a tag. + assert_eq!(html_to_plain("<p>"), ""); + // Unterminated tags drop the remainder; trailing breaks are dropped. + assert_eq!(html_to_plain("
a"), "a"); + assert_eq!(html_to_plain("a
"), "a"); + } + + #[test] + fn font_families_are_sorted_and_unique() { + let families = font_families(); + assert!( + !families.is_empty(), + "the system font database has no family" + ); + let mut sorted = families.clone(); + sorted.sort(); + sorted.dedup(); + assert_eq!(families, sorted); + // Cached: the second call hands out the same list. + assert_eq!(font_families(), families); + } + + #[test] + fn font_pixel_size_fallbacks() { + let base = plain("x", 72.0, 0.0); + // 72 pt at 3780 dots/meter == 96 DPI == 96.012 px. + assert!((font_px(&base) as f64 - 96.012).abs() < 0.01); + // 0 / non-finite point sizes fall back to 72 pt. + assert_eq!(font_px(&plain("x", 0.0, 0.0)), font_px(&base)); + assert_eq!(font_px(&plain("x", f64::NAN, 0.0)), font_px(&base)); + // Non-positive dots-per-meter falls back to 3780. + let mut req = plain("x", 72.0, 0.0); + req.dots_per_meter = 0; + assert_eq!(font_px(&req), font_px(&base)); + req.dots_per_meter = -3780; + assert_eq!(font_px(&req), font_px(&base)); + // Absurd sizes clamp instead of asking swash for a huge bitmap. + assert_eq!(font_px(&plain("x", 1.0e9, 0.0)), MAX_FONT_PX); + } + + #[test] + fn render_writes_premultiplied_white_rgba() { + let data = render_into(&plain("H", 72.0, 0.0), &scaled(1.0), 160, 160, 4); + let mut ink = 0usize; + for px in data.chunks_exact(4) { + let (r, g, b, a) = (px[0], px[1], px[2], px[3]); + if a == 0 && r == 0 && g == 0 && b == 0 { + continue; + } + ink += 1; + assert_eq!((r, g, b), (r, r, r), "non-white pixel {px:?}"); + assert!(r <= a, "not premultiplied: {px:?}"); + } + assert!(ink > 0, "the render painted nothing"); + } + + #[test] + fn render_writes_grayscale_coverage() { + let req = plain("H", 72.0, 0.0); + let gray = render_into(&req, &scaled(1.0), 160, 160, 1); + assert!(has_ink(&gray), "the render painted nothing"); + // The RGBA alpha is that same coverage (both blend over a zeroed + // buffer), so the two formats have to agree pixel for pixel. + let rgba = render_into(&req, &scaled(1.0), 160, 160, 4); + for (i, alpha) in rgba.chunks_exact(4).map(|px| px[3]).enumerate() { + assert_eq!(gray[i], alpha, "coverage mismatch at pixel {i}"); + } + } + + #[test] + fn render_scales_the_glyph() { + let req = plain("H", 72.0, 0.0); + let one = render_into(&req, &scaled(1.0), 256, 256, 1); + let two = render_into(&req, &scaled(2.0), 256, 256, 1); + let (x0, y0, x1, y1) = ink_bounds(&one, 256, 256).expect("scale 1 ink"); + let (u0, v0, u1, v1) = ink_bounds(&two, 256, 256).expect("scale 2 ink"); + assert!((u1 - u0) > (x1 - x0) * 3 / 2, "width did not scale"); + assert!((v1 - v0) > (y1 - y0) * 3 / 2, "height did not scale"); + } + + #[test] + fn render_skips_degenerate_scale() { + for scale in [0.0, -1.0, f64::NAN, f64::INFINITY] { + let data = render_into(&plain("H", 72.0, 0.0), &scaled(scale), 64, 64, 1); + assert!(!has_ink(&data), "scale {scale} painted something"); + } + } + + #[test] + fn render_clips_to_the_clip_rect() { + let req = plain("H", 72.0, 0.0); + let full = render_into(&req, &scaled(1.0), 160, 160, 1); + let (min_x, _, _, _) = ink_bounds(&full, 160, 160).expect("unclipped ink"); + assert!(min_x < 40, "the unclipped ink starts at {min_x}"); + + // A clip that keeps only the right half of the glyph. + let clipped = render_into( + &req, + &TextRenderTransform { + clip_enabled: true, + clip_offset_x: 40.0, + clip_width: 200.0, + clip_height: 200.0, + ..scaled(1.0) + }, + 160, + 160, + 1, + ); + let (cmin_x, _, cmax_x, cmax_y) = + ink_bounds(&clipped, 160, 160).expect("ink inside the clip"); + assert!(cmin_x >= 40, "ink left of the clip at {cmin_x}"); + assert!(cmin_x > min_x, "the clip removed nothing"); + assert!(cmax_x < 160 && cmax_y < 160); + + // An empty clip rect and a non-finite one paint nothing. + let empty = render_into( + &req, + &TextRenderTransform { + clip_enabled: true, + clip_width: 0.0, + clip_height: 0.0, + ..scaled(1.0) + }, + 160, + 160, + 1, + ); + assert!(!has_ink(&empty)); + let nan = render_into( + &req, + &TextRenderTransform { + clip_enabled: true, + clip_offset_x: f64::NAN, + clip_width: 64.0, + clip_height: 64.0, + ..scaled(1.0) + }, + 160, + 160, + 1, + ); + assert!(!has_ink(&nan)); + } + + #[test] + fn render_honors_draw_offset() { + let req = plain("H", 72.0, 0.0); + let base = render_into(&req, &scaled(1.0), 256, 256, 1); + let shifted = render_into( + &req, + &TextRenderTransform { + draw_offset_x: 100.0, + draw_offset_y: 100.0, + ..scaled(1.0) + }, + 256, + 256, + 1, + ); + let (bx, by, _, _) = ink_bounds(&base, 256, 256).expect("unshifted ink"); + let (sx, sy, _, _) = ink_bounds(&shifted, 256, 256).expect("shifted ink"); + // The offset is applied in device pixels after the scale, so the + // corners move by exactly the offset. + assert_eq!((sx, sy), (bx + 100, by + 100)); + } + + #[test] + fn hooks_install_and_drive_the_nodes() { + let _guard = HOOK_LOCK.lock().unwrap_or_else(|e| e.into_inner()); + use oak_node::nodes::textbackend::{text_measure_backend, text_render_backend}; + + install(); + let measure_fn = text_measure_backend().expect("install() sets the measure hook"); + let render_fn = text_render_backend().expect("install() sets the render hook"); + + let req = plain("Hello", 72.0, 0.0); + let size = measure_fn(&req); + assert!(size.width > 0.0 && size.height > 0.0); + + let mut data = vec![0u8; 192 * 192]; + render_fn( + &req, + &scaled(1.0), + TextRenderTarget { + data: &mut data, + width: 192, + height: 192, + linesize_bytes: 192, + channel_count: 1, + }, + ); + assert!(has_ink(&data), "the render hook painted nothing"); + + // Leave the process hooks uninstalled like `textbackend`'s own tests + // do, so no later test depends on this module's state. + set_text_backends(None, None); + } +} diff --git a/crates/oak-app/src/panels/ofx_params.rs b/crates/oak-app/src/panels/ofx_params.rs index 9e9a22d6d..656eba14a 100644 --- a/crates/oak-app/src/panels/ofx_params.rs +++ b/crates/oak-app/src/panels/ofx_params.rs @@ -26,15 +26,19 @@ //! - boolean → [`CheckBox`] //! - combo → [`ComboBox`] fed from the repeated `("combo_option", _)` //! properties; string-combo values come from `("combo_value", _)` -//! - text → [`EditableTextState`] +//! - text → [`EditableTextState`] (`text_input`; the `("multiline", true)` +//! property that [`super::effectchain::effect_params`] adds to the v3 +//! text node's text inputs builds a `text_area` instead) //! - vec2 / vec3 → one [`SpinBox`] per component //! - color → a swatch + deferred popup picker ([`OfxColorPicker`]: //! R/G/B/A sliders, live preview, hex input, Cancel/OK) //! - push button → a clickable button (`AppEngine::effect_push_button`) //! -//! Secret (HIDDEN) inputs never reach the snapshot, so they render -//! nothing; `ui_group` / `ui_page` become section titles. Every edit is -//! routed through [`AppEngine::set_effect_param`] (undoable). +//! Secret (HIDDEN) inputs never reach the snapshot the facade builds, and +//! the view skips them again on its own (a plugin or mock engine can hand +//! one over; the inspector must not show a secret input even then). +//! `ui_group` / `ui_page` become section titles. Every edit is routed +//! through [`AppEngine::set_effect_param`] (undoable). //! //! The control set is built once per expanded card — the stack view caches //! the params view per effect (recreating it per render would kill @@ -93,8 +97,13 @@ enum ControlKind { Spin(Vec<(Entityengine text
" + "文本\nsecond line" ); // Focus the field and type: the in-progress text must survive the @@ -2745,9 +2935,343 @@ mod tests { cx.run_until_parked(); assert_eq!( cx.read(|cx| editor.read(cx).as_str().to_string()), - "engine text
", + "文本\nsecond line", "the field re-syncs to the engine value on blur" ); } + + /// The v3 text node's parameter set renders as one structured control per + /// visible input — a multi-line text field, a font-family combo, colour + /// pickers, sliders, checkboxes, vec2 spinboxes — and the three hidden + /// inputs (the legacy text, the vertical align, the use-args toggle) + /// render nothing at all. + #[gpui::test] + async fn text3_params_render_as_structured_controls(cx: &mut TestAppContext) { + use crate::oakui::mock::MockEngine; + struct Host { + view: EntitySample Text
"`; -/// properties: `vieweronly = true`. +/// `LEGACY_DEFAULT_TEXT_HTML`; properties: `vieweronly = true`; flags: +/// hidden (REDESIGN: carried internally and kept for the serialized +/// compatibility of pre-redesign projects; the user-facing text is +/// [`PLAIN_TEXT_INPUT`]). pub const TEXT_INPUT: &str = "text_in"; /// Vertical alignment input id (C++ `k_vertical_alignment_input`). @@ -52,6 +73,65 @@ pub const USE_ARGS_INPUT: &str = "use_args_in"; /// flags: array; properties: `arraystart = 1`. pub const ARGS_INPUT: &str = "args_in"; +/// Plain text input id (REDESIGN addition, no C++ counterpart). Type: +/// text; default [`DEFAULT_PLAIN_TEXT`]. The editable user-facing text +/// and — when a text layout backend is installed — the text the +/// generator lays out; the legacy (hidden) [`TEXT_INPUT`] HTML stays as +/// the compatibility carrier. +pub const PLAIN_TEXT_INPUT: &str = "plain_text_in"; + +/// Font family input id (REDESIGN addition, no C++ counterpart). Type: +/// str-combo; default empty (the backend's default font). The option +/// list is injected by the backend layer (a `combo_option` property), +/// so this node has no [`TextGeneratorV3::input_combo_strings`] entry +/// for it; free-form entry is allowed. +pub const FONT_FAMILY_INPUT: &str = "font_family_in"; + +/// Font size input id (REDESIGN addition, no C++ counterpart). Type: +/// float; default `72.0`; properties: `min = 1.0`. +pub const FONT_SIZE_INPUT: &str = "font_size_in"; + +/// Outline enable toggle input id (REDESIGN addition, no C++ +/// counterpart). Type: boolean; default `false`. +pub const OUTLINE_ENABLED_INPUT: &str = "outline_enabled_in"; + +/// Outline color input id (REDESIGN addition, no C++ counterpart). +/// Type: color; default opaque black. +pub const OUTLINE_COLOR_INPUT: &str = "outline_color_in"; + +/// Outline width input id (REDESIGN addition, no C++ counterpart). +/// Type: float; default `2.0`; properties: `min = 0.0`. +pub const OUTLINE_WIDTH_INPUT: &str = "outline_width_in"; + +/// Glow enable toggle input id (REDESIGN addition, no C++ +/// counterpart). Type: boolean; default `false`. +pub const GLOW_ENABLED_INPUT: &str = "glow_enabled_in"; + +/// Glow color input id (REDESIGN addition, no C++ counterpart). Type: +/// color; default opaque yellow. +pub const GLOW_COLOR_INPUT: &str = "glow_color_in"; + +/// Glow radius input id (REDESIGN addition, no C++ counterpart). Type: +/// float; default `8.0`; properties: `min = 0.0`. +pub const GLOW_RADIUS_INPUT: &str = "glow_radius_in"; + +/// Font color input id (REDESIGN addition, no C++ counterpart). Type: +/// color; default opaque white (the backend rasterizes in white, so the +/// default leaves the raster unchanged). The glyphs are tinted with it +/// during rasterization, premultiplied — the same treatment the outline +/// and glow colorize passes give their own layers. +pub const COLOR_INPUT: &str = "color_in"; + +/// Default of the legacy [`TEXT_INPUT`] HTML payload (the C++ +/// `k_text_input` default, verbatim). Used by [`create`] and by +/// [`migrate_legacy_html`] to recognize an untouched legacy value. +pub const LEGACY_DEFAULT_TEXT_HTML: &str = + "Sample Text
"; + +/// Default of [`PLAIN_TEXT_INPUT`] (REDESIGN addition): the localized +/// placeholder text new text nodes start with. +pub const DEFAULT_PLAIN_TEXT: &str = "文本"; + /// Vertical alignment (C++ `TextGeneratorV3::VerticalAlignment`, values /// `k_v_align_top = 0`, `k_v_align_middle = 1`, `k_v_align_bottom = 2`). #[derive(Clone, Copy, Debug, PartialEq, Eq)] @@ -96,11 +176,12 @@ pub struct TextGeneratorV3 { dont_emit_valign: bool, } -/// `Variant::to_string()` for the text input (Text payload, with a -/// numeric fallback for mis-typed connections). +/// `Variant::to_string()` for the text inputs (Text and string-combo +/// payloads — the latter for [`FONT_FAMILY_INPUT`] — with a numeric +/// fallback for mis-typed connections). fn to_text(v: &NodeValue) -> String { match v { - NodeValue::Text(s) => s.clone(), + NodeValue::Text(s) | NodeValue::StrCombo(s) => s.clone(), other => other.to_double().to_string(), } } @@ -121,6 +202,132 @@ fn to_vec2(v: &NodeValue) -> [f64; 2] { } } +/// Largest rasterization dimension accepted from `size_in`. Both the +/// CPU staging buffer and the intermediate GPU textures are `w * h * 4` +/// bytes, so an absurd shape size is clamped rather than allocated. +const MAX_RASTER_SIZE: i32 = 8192; + +/// Shader id of the outline dilation pass: a square dilation (the +/// algorithm of [`super::dilate`], with the radius read from +/// [`OUTLINE_WIDTH_INPUT`]). +pub const OUTLINE_DILATE_SHADER_ID: &str = "outline_dilate"; + +/// Shader id of the outline colorize pass: multiplies the dilated +/// coverage by [`OUTLINE_COLOR_INPUT`]. +pub const OUTLINE_COLORIZE_SHADER_ID: &str = "outline_colorize"; + +/// Shader id of the glow blur pass. The job runs one iteration per axis +/// (horizontal, then vertical). +pub const GLOW_BLUR_SHADER_ID: &str = "glow_blur"; + +/// Shader id of the glow colorize pass: multiplies the blurred coverage +/// by [`GLOW_COLOR_INPUT`]. +pub const GLOW_COLORIZE_SHADER_ID: &str = "glow_colorize"; + +/// Effect-texture input id shared by the four post-process shaders: the +/// coverage texture produced by the preceding pass. +const POST_TEXTURE_INPUT: &str = "tex_in"; + +/// Resolution input id. The raster resolution is inserted explicitly so +/// the evaluation pass cannot pre-fill it with the sequence resolution. +const RESOLUTION_INPUT: &str = "resolution_in"; + +/// Fragment shader of the outline dilation pass: the square +/// `(2r+1)^2` max filter of [`super::dilate`], with the radius taken +/// from `outline_width_in` (rounded and clamped to `0..=7`) instead of +/// the dilate node's own input and the rest copied verbatim. +const OUTLINE_DILATE_FRAG: &str = r#"uniform sampler2D tex_in; +uniform float outline_width_in; +uniform vec2 resolution_in; + +in vec2 ove_texcoord; +out vec4 frag_color; + +void main() { + int radius = int(clamp(outline_width_in, 0.0, 7.0) + 0.5); + vec2 texel = vec2(1.0) / resolution_in; + + vec4 acc = texture(tex_in, ove_texcoord); + for (int dy = -radius; dy <= radius; ++dy) { + for (int dx = -radius; dx <= radius; ++dx) { + vec2 uv = ove_texcoord + vec2(float(dx), float(dy)) * texel; + acc = max(acc, texture(tex_in, uv)); + } + } + + frag_color = acc; +} +"#; + +/// Fragment shader of the outline colorize pass: tint the coverage with +/// [`OUTLINE_COLOR_INPUT`] and emit it premultiplied, so it composites +/// as `color * alpha` over whatever is beneath it. +const OUTLINE_COLORIZE_FRAG: &str = r#"uniform sampler2D tex_in; +uniform vec4 outline_color_in; + +in vec2 ove_texcoord; +out vec4 frag_color; + +void main() { + vec4 coverage = texture(tex_in, ove_texcoord); + float alpha = coverage.a * outline_color_in.a; + + frag_color = vec4(outline_color_in.rgb * alpha, alpha); +} +"#; + +/// Fragment shader of the glow blur pass: a box blur over the axis +/// selected by `ove_iteration` (0 = horizontal, 1 = vertical), taps one +/// texel apart and averaged over `2r + 1`. `glow_radius_in` is rounded +/// and clamped to `0..=64`; a sub-pixel radius passes the texture +/// through. +const GLOW_BLUR_FRAG: &str = r#"uniform sampler2D tex_in; +uniform float glow_radius_in; +uniform vec2 resolution_in; + +uniform int ove_iteration; + +in vec2 ove_texcoord; +out vec4 frag_color; + +void main() { + int radius = int(clamp(glow_radius_in, 0.0, 64.0) + 0.5); + if (radius < 1) { + frag_color = texture(tex_in, ove_texcoord); + return; + } + + vec4 composite = vec4(0.0); + for (int i = -radius; i <= radius; ++i) { + vec2 uv = ove_texcoord; + if (ove_iteration == 0) { + uv.x += float(i) / resolution_in.x; + } else { + uv.y += float(i) / resolution_in.y; + } + composite += texture(tex_in, uv); + } + + frag_color = composite / float(radius * 2 + 1); +} +"#; + +/// Fragment shader of the glow colorize pass: tint the blurred coverage +/// with [`GLOW_COLOR_INPUT`] and emit it premultiplied. +const GLOW_COLORIZE_FRAG: &str = r#"uniform sampler2D tex_in; +uniform vec4 glow_color_in; + +in vec2 ove_texcoord; +out vec4 frag_color; + +void main() { + vec4 coverage = texture(tex_in, ove_texcoord); + float alpha = coverage.a * glow_color_in.a; + + frag_color = vec4(glow_color_in.rgb * alpha, alpha); +} +"#; + impl TextGeneratorV3 { /// Map our alignment to the gizmo's alignment int (C++ /// `get_qt_alignment_from_ours()`): Top -> `TextGizmo::k_align_top`, @@ -258,10 +465,21 @@ impl NodeBehavior for TextGeneratorV3 { /// "Text", `valign_in` -> "Vertical Alignment" (combo strings /// Top/Middle/Bottom), `args_in` -> "Arguments"; the base class /// retranslate covers the inherited shape inputs and `base_in` - /// ("Base"). + /// ("Base"). The redesign inputs are named here too ("Text" for + /// `plain_text_in`, "Font Family", "Font Size", "Outline"/"Outline + /// Color"/"Outline Width", "Glow"/"Glow Color"/"Glow Radius"). fn input_name<'a>(&self, id: &'a str) -> &'a str { match id { - TEXT_INPUT => "Text", + TEXT_INPUT | PLAIN_TEXT_INPUT => "Text", + FONT_FAMILY_INPUT => "Font Family", + FONT_SIZE_INPUT => "Font Size", + OUTLINE_ENABLED_INPUT => "Outline", + OUTLINE_COLOR_INPUT => "Outline Color", + OUTLINE_WIDTH_INPUT => "Outline Width", + GLOW_ENABLED_INPUT => "Glow", + GLOW_COLOR_INPUT => "Glow Color", + GLOW_RADIUS_INPUT => "Glow Radius", + COLOR_INPUT => "Color", VERTICAL_ALIGNMENT_INPUT => "Vertical Alignment", ARGS_INPUT => "Arguments", crate::nodes::generatorwithmerge::BASE_INPUT => "Base", @@ -271,7 +489,9 @@ impl NodeBehavior for TextGeneratorV3 { /// Combo input option labels (C++ `retranslate()` / /// `set_combo_box_strings`): `valign_in` -> "Top", "Middle", - /// "Bottom". + /// "Bottom". The redesign's `font_family_in` is a str-combo whose + /// option list is injected by the backend layer, so it has no + /// static labels here. fn input_combo_strings(&self, id: &str) -> Vec<&'static str> { match id { VERTICAL_ALIGNMENT_INPUT => vec!["Top", "Middle", "Bottom"], @@ -279,6 +499,22 @@ impl NodeBehavior for TextGeneratorV3 { } } + /// Shader code request: the merged generate shader is served under + /// the `"mrg"` request (shared with + /// [`crate::nodes::generatorwithmerge`]), the four post-process passes + /// (REDESIGN, no C++ counterpart) under their shader ids. Every other + /// request is unhandled. + fn shader_code(&self, request: &str) -> Option`), and whitespace is neither +/// collapsed nor trimmed (so `
a
b
` becomes `ab`). It only +/// exists to migrate the legacy [`TEXT_INPUT`] payload into +/// [`PLAIN_TEXT_INPUT`]. +pub fn strip_html_to_plain(html: &str) -> String { + /// Whether `chars` starts with the (ASCII) `entity` text. + fn starts_with(chars: &[char], entity: &str) -> bool { + let mut it = chars.iter(); + entity.chars().all(|c| it.next() == Some(&c)) + } + + const ENTITIES: [(&str, &str); 6] = [ + ("&", "&"), + ("<", "<"), + (">", ">"), + (""", "\""), + ("'", "'"), + (" ", " "), + ]; + + let chars: VecSample Text
".to_string()), + NodeValue::Text(LEGACY_DEFAULT_TEXT_HTML.to_string()), ); + text.flags |= crate::input::flags::HIDDEN; text.properties = vec![("vieweronly".to_string(), NodeValue::Boolean(true))]; core.add_input(text); + core.add_input(crate::input::Input::new( + FONT_FAMILY_INPUT, + crate::value::ValueType::StrCombo, + NodeValue::StrCombo(String::new()), + )); + + let mut font_size = crate::input::Input::new( + FONT_SIZE_INPUT, + crate::value::ValueType::Float, + NodeValue::Float(72.0), + ); + font_size.properties = vec![("min".to_string(), NodeValue::Float(1.0))]; + core.add_input(font_size); + + core.add_input(crate::input::Input::new( + OUTLINE_ENABLED_INPUT, + crate::value::ValueType::Boolean, + NodeValue::Boolean(false), + )); + core.add_input(crate::input::Input::new( + OUTLINE_COLOR_INPUT, + crate::value::ValueType::Color, + NodeValue::Color([0.0, 0.0, 0.0, 1.0]), + )); + let mut outline_width = crate::input::Input::new( + OUTLINE_WIDTH_INPUT, + crate::value::ValueType::Float, + NodeValue::Float(2.0), + ); + outline_width.properties = vec![("min".to_string(), NodeValue::Float(0.0))]; + core.add_input(outline_width); + + core.add_input(crate::input::Input::new( + GLOW_ENABLED_INPUT, + crate::value::ValueType::Boolean, + NodeValue::Boolean(false), + )); + core.add_input(crate::input::Input::new( + GLOW_COLOR_INPUT, + crate::value::ValueType::Color, + NodeValue::Color([1.0, 1.0, 0.0, 1.0]), + )); + let mut glow_radius = crate::input::Input::new( + GLOW_RADIUS_INPUT, + crate::value::ValueType::Float, + NodeValue::Float(8.0), + ); + glow_radius.properties = vec![("min".to_string(), NodeValue::Float(0.0))]; + core.add_input(glow_radius); + + core.add_input(crate::input::Input::new( + COLOR_INPUT, + crate::value::ValueType::Color, + NodeValue::Color([1.0, 1.0, 1.0, 1.0]), + )); + + // Hidden alignment / args inputs, unchanged by the redesign. let mut valign = crate::input::Input::new( VERTICAL_ALIGNMENT_INPUT, crate::value::ValueType::Combo, @@ -610,7 +1458,9 @@ pub fn register(meta: &mut VecHi
"); assert_eq!(req.mode, TextLayoutMode::OliveHtml); assert_eq!(req.dots_per_meter, 3780); assert_eq!(req.wrap_width, 400.0); } + #[test] + fn layout_request_plain_text_path_uses_structured_inputs() { + let mut row = NodeValueRow::default(); + row.insert( + PLAIN_TEXT_INPUT.to_string(), + NodeValue::Text("hello".to_string()), + ); + row.insert( + FONT_FAMILY_INPUT.to_string(), + NodeValue::StrCombo("Noto Sans".to_string()), + ); + row.insert(FONT_SIZE_INPUT.to_string(), NodeValue::Float(48.0)); + row.insert( + crate::nodes::shapenodebase::SIZE_INPUT.to_string(), + NodeValue::Vec2([400.0, 300.0]), + ); + // The row also carries legacy HTML: the plain path must ignore it. + row.insert( + TEXT_INPUT.to_string(), + NodeValue::Text("legacy
".to_string()), + ); + let req = TextGeneratorV3::layout_request_path(true, &row); + assert_eq!(req.text, "hello"); + assert_eq!(req.mode, TextLayoutMode::PlainText); + assert_eq!(req.font_family, "Noto Sans"); + assert_eq!(req.font_size_pt, 48.0); + assert_eq!(req.dots_per_meter, 3780); + assert_eq!(req.wrap_width, 400.0); + } + + #[test] + fn job_text_prefers_the_row_value() { + let (core, _behavior) = create(); + let mut row = NodeValueRow::default(); + row.insert( + PLAIN_TEXT_INPUT.to_string(), + NodeValue::Text("row plain".to_string()), + ); + row.insert( + TEXT_INPUT.to_string(), + NodeValue::Text("row html".to_string()), + ); + assert_eq!( + TextGeneratorV3::job_text(true, &core, &row, Rational::new(0, 1)), + "row plain" + ); + assert_eq!( + TextGeneratorV3::job_text(false, &core, &row, Rational::new(0, 1)), + "row html" + ); + } + + #[test] + fn job_text_falls_back_to_the_core_value() { + let (mut core, _behavior) = create(); + core.set_standard_value( + PLAIN_TEXT_INPUT, + -1, + NodeValue::Text("core plain".to_string()), + ); + core.set_standard_value(TEXT_INPUT, -1, NodeValue::Text("core html".to_string())); + let row = NodeValueRow::default(); + assert_eq!( + TextGeneratorV3::job_text(true, &core, &row, Rational::new(0, 1)), + "core plain" + ); + assert_eq!( + TextGeneratorV3::job_text(false, &core, &row, Rational::new(0, 1)), + "core html" + ); + } + #[test] fn base_and_draw_offsets() { let size = [400.0, 300.0]; @@ -790,8 +1741,20 @@ mod tests { ); } + /// Serializes the tests that install a process-global text backend. + /// (The `textbackend` module's own tests use a different lock, so they + /// are not mutually excluded — same exposure as the pre-existing + /// `measure_without_backend_returns_zero_size`.) + static BACKEND_LOCK: std::sync::Mutex<()> = std::sync::Mutex::new(()); + + /// Measure hook for tests that only need "a backend is installed". + fn noop_measure(_req: &TextLayoutRequest) -> TextLayoutSize { + TextLayoutSize::default() + } + #[test] fn measure_without_backend_returns_zero_size() { + let _guard = BACKEND_LOCK.lock().unwrap(); crate::nodes::textbackend::set_text_backends(None, None); let mut row = NodeValueRow::default(); row.insert( @@ -803,6 +1766,40 @@ mod tests { assert_eq!(doc.height, 0.0); } + #[test] + fn value_uses_plain_text_when_a_backend_is_installed() { + let _guard = BACKEND_LOCK.lock().unwrap(); + crate::nodes::textbackend::set_text_backends(Some(noop_measure), None); + assert!(TextGeneratorV3::plain_text_path()); + + // The row carries an empty legacy HTML only: the non-empty plain + // text default is what makes the job push, so this fails on the + // legacy path (empty text, no base -> empty table). + let (core, behavior) = create(); + let mut row = NodeValueRow::default(); + row.insert(TEXT_INPUT.to_string(), NodeValue::Text(String::new())); + let mut table = NodeValueTable::default(); + behavior.value(&core, &row, Rational::new(0, 1), &mut table); + assert!(matches!( + table.get(ValueType::Texture), + Some(NodeValue::Texture(h)) if h.is_null() + )); + + // The public layout request follows the installed backend. + let mut req_row = NodeValueRow::default(); + req_row.insert( + PLAIN_TEXT_INPUT.to_string(), + NodeValue::Text("hi".to_string()), + ); + assert_eq!( + TextGeneratorV3::layout_request(&req_row).mode, + TextLayoutMode::PlainText + ); + + crate::nodes::textbackend::set_text_backends(None, None); + assert!(!TextGeneratorV3::plain_text_path()); + } + #[test] fn value_pushes_job_when_text_nonempty() { let (core, behavior) = create(); @@ -862,6 +1859,10 @@ mod tests { fn value_pushes_nothing_when_text_empty_and_no_base() { let (core, behavior) = create(); let mut row = NodeValueRow::default(); + // Both text inputs are emptied explicitly: which one `value` reads + // depends on the process-global backend state, which the tests that + // install one (own lock, and `textbackend`'s) change concurrently. + row.insert(PLAIN_TEXT_INPUT.to_string(), NodeValue::Text(String::new())); row.insert(TEXT_INPUT.to_string(), NodeValue::Text(String::new())); let mut table = NodeValueTable::default(); behavior.value(&core, &row, Rational::new(0, 1), &mut table); @@ -921,4 +1922,464 @@ mod tests { assert_eq!(copy.type_id(), "org.olivevideoeditor.Olive.text3"); assert_eq!(copy.name(), "Text"); } + + #[test] + fn redesign_inputs_have_defaults_and_flags() { + let (core, _behavior) = create(); + + let plain = core.get_input(PLAIN_TEXT_INPUT).unwrap(); + assert_eq!(plain.value_type, ValueType::Text); + assert_eq!( + plain.default, + NodeValue::Text(DEFAULT_PLAIN_TEXT.to_string()) + ); + + let family = core.get_input(FONT_FAMILY_INPUT).unwrap(); + assert_eq!(family.value_type, ValueType::StrCombo); + assert_eq!(family.default, NodeValue::StrCombo(String::new())); + + let size = core.get_input(FONT_SIZE_INPUT).unwrap(); + assert_eq!(size.value_type, ValueType::Float); + assert_eq!(size.default, NodeValue::Float(72.0)); + assert!(size + .properties + .iter() + .any(|(k, v)| k == "min" && v == &NodeValue::Float(1.0))); + + let outline = core.get_input(OUTLINE_ENABLED_INPUT).unwrap(); + assert_eq!(outline.value_type, ValueType::Boolean); + assert_eq!(outline.default, NodeValue::Boolean(false)); + + let outline_color = core.get_input(OUTLINE_COLOR_INPUT).unwrap(); + assert_eq!(outline_color.value_type, ValueType::Color); + assert_eq!( + outline_color.default, + NodeValue::Color([0.0, 0.0, 0.0, 1.0]) + ); + + let outline_width = core.get_input(OUTLINE_WIDTH_INPUT).unwrap(); + assert_eq!(outline_width.value_type, ValueType::Float); + assert_eq!(outline_width.default, NodeValue::Float(2.0)); + assert!(outline_width + .properties + .iter() + .any(|(k, v)| k == "min" && v == &NodeValue::Float(0.0))); + + let glow = core.get_input(GLOW_ENABLED_INPUT).unwrap(); + assert_eq!(glow.value_type, ValueType::Boolean); + assert_eq!(glow.default, NodeValue::Boolean(false)); + + let glow_color = core.get_input(GLOW_COLOR_INPUT).unwrap(); + assert_eq!(glow_color.value_type, ValueType::Color); + assert_eq!(glow_color.default, NodeValue::Color([1.0, 1.0, 0.0, 1.0])); + + let glow_radius = core.get_input(GLOW_RADIUS_INPUT).unwrap(); + assert_eq!(glow_radius.value_type, ValueType::Float); + assert_eq!(glow_radius.default, NodeValue::Float(8.0)); + assert!(glow_radius + .properties + .iter() + .any(|(k, v)| k == "min" && v == &NodeValue::Float(0.0))); + + // Every redesign input is user-facing (none hidden). + for id in [ + PLAIN_TEXT_INPUT, + FONT_FAMILY_INPUT, + FONT_SIZE_INPUT, + OUTLINE_ENABLED_INPUT, + OUTLINE_COLOR_INPUT, + OUTLINE_WIDTH_INPUT, + GLOW_ENABLED_INPUT, + GLOW_COLOR_INPUT, + GLOW_RADIUS_INPUT, + ] { + assert_eq!( + core.get_input(id).unwrap().flags & crate::input::flags::HIDDEN, + 0 + ); + } + + // The legacy input keeps its default and vieweronly property, and + // is now hidden. + let legacy = core.get_input(TEXT_INPUT).unwrap(); + assert_eq!( + legacy.default, + NodeValue::Text(LEGACY_DEFAULT_TEXT_HTML.to_string()) + ); + assert_ne!(legacy.flags & crate::input::flags::HIDDEN, 0); + assert!(legacy + .properties + .iter() + .any(|(k, v)| k == "vieweronly" && v == &NodeValue::Boolean(true))); + + // The shape base still has no color input of its own + // (ShapeNodeBase(false)); the REDESIGN wave-3 font color input + // takes that exact slot (white default). + assert_eq!( + core.get_input(crate::nodes::shapenodebase::COLOR_INPUT) + .unwrap() + .default, + NodeValue::Color([1.0, 1.0, 1.0, 1.0]) + ); + } + + #[test] + fn strip_html_to_plain_drops_tags() { + assert_eq!(strip_html_to_plain("a
b
"), "ab"); + assert_eq!(strip_html_to_plain("a b
"), "a b"); + // A complete tag drops only itself; the text around it stays. + assert_eq!(strip_html_to_plain("abc"), "abc");
+ // An unterminated tag swallows the remainder.
+ assert_eq!(strip_html_to_plain("a ");
+ }
+
+ #[test]
+ fn migrate_legacy_html_moves_stripped_text_once() {
+ let (mut core, _behavior) = create();
+ core.set_standard_value(
+ TEXT_INPUT,
+ -1,
+ NodeValue::Text(" Hello World Hello World legacy x Sample Text