From 3ca794194f8255b780387678bdf2bd4d6c5dd2d9 Mon Sep 17 00:00:00 2001 From: torsten Date: Fri, 30 Oct 2026 10:34:21 +0100 Subject: [PATCH] feat: Segmente beschriften und Labels ein-/ausblenden MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Freitext-Label pro PathSegment (max. 40 Zeichen), getrimmt, mit Undo/Redo, Dirty-State und Persistenz - Label-Dialog für das ausgewählte Segment; leeren entfernt die Beschriftung, Enter übernimmt direkt - Globaler Schalter „Labels“ in der Timing-Leiste blendet alle Beschriftungen in der Ansicht aus - Canvas zeichnet Labels am Segmentmittelpunkt mit Pill-Hintergrund, ausgewähltes Segment mit Akzentrahmen; Präsentation zeigt sie - SVG-Export mit weiß umrandeten Labels, PNG-Export immer mit Labels - Esc hebt die Segmentauswahl auf - Tests: Label-API, Dialog, Undo/Redo, Persistenz, SVG-Ausgabe - Manueller Visual-Check für Labels (tests/manual/capture_labels.gd) --- docs/architecture.md | 21 +++-- docs/roadmap.md | 8 ++ rinkplanner/scenes/whiteboard/whiteboard.tscn | 48 ++++++++++ .../whiteboard/ctrl/whiteboard_controller.gd | 91 ++++++++++++++++++ rinkplanner/src/whiteboard/io/export_sheet.gd | 1 + rinkplanner/src/whiteboard/io/svg_exporter.gd | 35 +++++++ .../src/whiteboard/view/rink_canvas.gd | 94 +++++++++++++++++++ rinkplanner/tests/manual/capture_labels.gd | 60 ++++++++++++ .../tests/manual/capture_labels.gd.uid | 1 + rinkplanner/tests/run_export_tests.gd | 24 +++-- rinkplanner/tests/run_history_tests.gd | 24 +++++ rinkplanner/tests/run_whiteboard_tests.gd | 83 ++++++++++++++++ 12 files changed, 476 insertions(+), 14 deletions(-) create mode 100644 rinkplanner/tests/manual/capture_labels.gd create mode 100644 rinkplanner/tests/manual/capture_labels.gd.uid diff --git a/docs/architecture.md b/docs/architecture.md index 9a3b581..d1236fe 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -51,7 +51,7 @@ Implementiert in `rinkplanner/src/core/model/`: | :--- | :--- | | `Routine` | Wurzelaggregat, Validierung, Gesamtdauer/-länge, Section-Lookup | | `RoutineSection` | chronologischer Block, Ghosting-Einheit, Segmentliste | -| `PathSegment` | durchgehender Pfad mit Richtung, Kante, Dauer, Element-Marker | +| `PathSegment` | durchgehender Pfad mit Richtung, Kante, Dauer, Element-Marker, Label | | `RinkDimensions` | Maße, Koordinaten, Punkte-/Kurvenprüfung | ### Entscheidungen @@ -75,11 +75,17 @@ erkannt. Achse (−15 m … +15 m). Nur die View rechnet in Pixel um. Gespeicherte Daten sind damit auflösungsunabhängig. -**D5 – IDs sind Pflicht und global eindeutig.** +**D5 – Beschriftungen sind Freitext am Segment.** +Jedes Segment kann ein `label` tragen (max. 40 Zeichen, getrimmt). Es wird im +aktiven Abschnitt neben dem Segmentmittelpunkt gezeichnet, in Präsentation und +Export für alle sichtbaren Abschnitte. Der globale Schalter „Labels“ blendet +alle Beschriftungen in der Ansicht aus; Exporte enthalten sie immer. + +**D6 – IDs sind Pflicht und global eindeutig.** `routine_id`, `section_id` und `segment_id` werden validiert. Die ID-Erzeugung gehört in den Controller, nicht ins Modell. -**D6 – Validierung liefert Fehlertexte.** +**D7 – Validierung liefert Fehlertexte.** `validate() -> PackedStringArray` ist die primäre API; `is_valid()` ist nur eine Abkürzung. So kann die UI Fehler konkret anzeigen. @@ -250,12 +256,13 @@ Aktueller Stand: Routine-Validierung. - **Canvas:** 90 Assertions für Meter→Pixel-Mapping, Fit/Zoom/Pan, Rink-Kontur und die reine Bogen-Geometrie. -- **Whiteboard:** 129 Assertions für Controller-Verdrahtung, Segmenterzeugung, +- **Whiteboard:** 149 Assertions für Controller-Verdrahtung, Segmenterzeugung, Linien-/Bogenpfade, Klemmen an der Bande, Auswahl, Griff- und Richtungs-/Kanten-Bearbeitung, Segmentlöschung, Section-Verwaltung, - Ghosting-Zustand, Speichern/Laden, Schema-Prüfung, Dirty-State, + Ghosting-Zustand, Segment-Labels inklusive Dialog und Sichtbarkeits-Schalter, + Speichern/Laden, Schema-Prüfung, Dirty-State, Navigationsmodus und den Maus-Drag-Pfad. -- **History:** 47 Assertions für Undo/Redo von Segmenten, Kanten, Sections, +- **History:** 53 Assertions für Undo/Redo von Segmenten, Kanten, Labels, Sections, Zeichengesten und Griff-Bearbeitung, Toolbar-Buttons, Erhalt der Ansicht sowie das Zurücksetzen der Historie. - **Playback:** 38 Assertions für Dauer/Timeline, Vorwärts-/Rückwärts- @@ -263,7 +270,7 @@ Aktueller Stand: Button-Verdrahtung, Scrubbing und Geschwindigkeitswechsel. - **Timing:** 41 Assertions für Dauer-/Tempo-Kopplung, Level-Presets, Kalibrierung, Undo, Persistenz und Schema-1-Migration. -- **Export:** 17 Assertions für SVG-Struktur, Titel-Escaping, Section-Filter, +- **Export:** 19 Assertions für SVG-Struktur, Titel-Escaping, Segment-Labels, Section-Filter, Segmentfarben/-strichelung und das Schreiben der Exportdatei. - **Touch/Tablet:** 21 Assertions für Ein-Finger-Zeichnen, Zwei-Finger-Pan, Pinch-Zoom, Tipp-Auswahl, Griff-Bearbeitung, Abbruch bei zweitem Finger, diff --git a/docs/roadmap.md b/docs/roadmap.md index d7b7291..10f6d40 100644 --- a/docs/roadmap.md +++ b/docs/roadmap.md @@ -50,6 +50,14 @@ Voraussetzung für Phase 1. - [x] Export-Tests: Geometrie, Section-Reihenfolge, Sichtbarkeit - [x] Export-Dialog mit Dateiname, Format und Umfang +### Erledigt: Segment-Labels + +- [x] Freitext-Label pro Segment (max. 40 Zeichen), Undo/Redo und Persistenz +- [x] Label-Dialog für das ausgewählte Segment, leeren entfernt das Label +- [x] Globaler Schalter „Labels“ blendet alle Beschriftungen in der Ansicht aus +- [x] Labels im Canvas (auch Präsentation) sowie in SVG- und PNG-Export +- [ ] Optional: Label-Vorlagen (Elementkürzel) und Auswahl aus einer Liste + ### Erledigt: Builds - [x] Linux-, Windows- und macOS-Preset plus `tools/export_*.sh` diff --git a/rinkplanner/scenes/whiteboard/whiteboard.tscn b/rinkplanner/scenes/whiteboard/whiteboard.tscn index 576e1c3..2782496 100644 --- a/rinkplanner/scenes/whiteboard/whiteboard.tscn +++ b/rinkplanner/scenes/whiteboard/whiteboard.tscn @@ -303,6 +303,15 @@ theme_override_font_sizes/font_size = 15 text = "Kein Segment ausgewählt" vertical_alignment = 1 +[node name="LabelButton" type="Button" parent="Layout/TimingBar/TimingContent"] +unique_name_in_owner = true +custom_minimum_size = Vector2(84, 56) +layout_mode = 2 +theme_override_font_sizes/font_size = 15 +disabled = true +text = "Label" +tooltip_text = "Beschriftung für das ausgewählte Segment" + [node name="TimingSeparator1" type="VSeparator" parent="Layout/TimingBar/TimingContent"] layout_mode = 2 @@ -393,6 +402,16 @@ disabled = true text = "Standard" tooltip_text = "Auf Adult Gold (4,3 m/s) zurücksetzen" +[node name="LabelsToggle" type="Button" parent="Layout/TimingBar/TimingContent"] +unique_name_in_owner = true +custom_minimum_size = Vector2(96, 56) +layout_mode = 2 +theme_override_font_sizes/font_size = 15 +toggle_mode = true +button_pressed = true +text = "Labels" +tooltip_text = "Beschriftungen ein- oder ausblenden" + [node name="PlaybackBar" type="PanelContainer" parent="Layout"] custom_minimum_size = Vector2(0, 72) layout_mode = 2 @@ -495,6 +514,35 @@ unique_name_in_owner = true custom_minimum_size = Vector2(0, 56) layout_mode = 2 +[node name="SegmentLabelDialog" type="ConfirmationDialog" parent="."] +unique_name_in_owner = true +title = "Segment beschriften" +size = Vector2i(480, 240) +ok_button_text = "Übernehmen" +cancel_button_text = "Abbrechen" + +[node name="SegmentLabelBox" type="VBoxContainer" parent="SegmentLabelDialog"] +offset_left = 8.0 +offset_top = 8.0 +offset_right = 472.0 +offset_bottom = 170.0 +theme_override_constants/separation = 8 + +[node name="SegmentLabelHint" type="Label" parent="SegmentLabelDialog/SegmentLabelBox"] +layout_mode = 2 +theme_override_colors/font_color = Color(0.580392, 0.639216, 0.721569, 1) +theme_override_font_sizes/font_size = 15 +text = "Text für das ausgewählte Segment. Leer lassen entfernt die Beschriftung." + +[node name="SegmentLabelEdit" type="LineEdit" parent="SegmentLabelDialog/SegmentLabelBox"] +unique_name_in_owner = true +custom_minimum_size = Vector2(0, 56) +layout_mode = 2 +theme_override_font_sizes/font_size = 17 +placeholder_text = "z. B. 3Lz, Eingang, Choreo" +max_length = 40 +caret_blink = true + [node name="DeleteDialog" type="ConfirmationDialog" parent="."] unique_name_in_owner = true title = "Abschnitt löschen" diff --git a/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd b/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd index c836cff..1541a0c 100644 --- a/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd +++ b/rinkplanner/src/whiteboard/ctrl/whiteboard_controller.gd @@ -88,6 +88,10 @@ const COMPACT_LAYOUT_WIDTH := 1280.0 @onready var playback_timeline: HSlider = %PlaybackTimeline @onready var speed_option: OptionButton = %SpeedOption @onready var timing_selection_label: Label = %TimingSelectionLabel +@onready var label_button: Button = %LabelButton +@onready var labels_toggle: Button = %LabelsToggle +@onready var segment_label_dialog: ConfirmationDialog = %SegmentLabelDialog +@onready var segment_label_edit: LineEdit = %SegmentLabelEdit @onready var duration_minus_button: Button = %DurationMinusButton @onready var duration_plus_button: Button = %DurationPlusButton @onready var duration_value_label: Label = %DurationValueLabel @@ -142,6 +146,7 @@ func _ready() -> void: _setup_playback_controls() _setup_timing_controls() _setup_export_controls() + labels_toggle.set_pressed_no_signal(rink_canvas.labels_visible) tool_option.item_selected.connect(_on_tool_selected) forward_button.pressed.connect( @@ -191,6 +196,10 @@ func _ready() -> void: reset_timing_button.pressed.connect(_reset_selected_timing) calibration_dialog.confirmed.connect(_on_calibration_confirmed) export_dialog.confirmed.connect(_on_export_confirmed) + label_button.pressed.connect(_open_label_dialog) + labels_toggle.toggled.connect(_on_labels_toggled) + segment_label_dialog.confirmed.connect(_on_label_confirmed) + segment_label_edit.text_submitted.connect(_on_label_submitted) resized.connect(_apply_responsive_layout) _apply_display_scale() @@ -273,6 +282,64 @@ func get_selected_segment() -> PathSegment: return _find_segment(_selected_segment_id) +func get_selected_segment_label() -> String: + var segment := get_selected_segment() + return segment.label if segment != null else "" + + +## Sets or clears the free-text label of the selected segment. Returns true +## when the model changed (and an undo entry was recorded). +func set_selected_segment_label(text: String) -> bool: + var segment := get_selected_segment() + if segment == null: + return false + + var cleaned := text.strip_edges() + if cleaned == segment.label: + return false + + _record_undo() + segment.label = cleaned + _mark_dirty() + rink_canvas.refresh() + _update_status() + return true + + +func are_labels_visible() -> bool: + return rink_canvas.labels_visible + + +func set_labels_visible(visible: bool) -> void: + rink_canvas.set_labels_visible(visible) + labels_toggle.set_pressed_no_signal(visible) + + +func _on_labels_toggled(pressed: bool) -> void: + set_labels_visible(pressed) + + +func _open_label_dialog() -> void: + var segment := get_selected_segment() + if segment == null: + return + + segment_label_edit.text = segment.label + segment_label_dialog.popup_centered(Vector2i(480, 220)) + segment_label_edit.grab_focus() + segment_label_edit.select_all() + + +func _on_label_confirmed() -> void: + set_selected_segment_label(segment_label_edit.text) + + +func _on_label_submitted(text: String) -> void: + segment_label_edit.text = text + segment_label_dialog.hide() + set_selected_segment_label(text) + + func add_section() -> RoutineSection: _record_undo() _section_counter += 1 @@ -549,6 +616,14 @@ func _clone_segment(source: PathSegment) -> PathSegment: return clone +func clear_selection() -> void: + if _selected_segment_id.is_empty(): + return + _selected_segment_id = "" + rink_canvas.set_selected_segment("") + _update_status() + + func delete_selected_segment() -> bool: var segment := get_selected_segment() if segment == null or _active_section == null: @@ -582,6 +657,7 @@ func _unhandled_key_input(event: InputEvent) -> void: or open_dialog.visible or confirm_dialog.visible or message_dialog.visible + or segment_label_dialog.visible ): return @@ -597,6 +673,10 @@ func _unhandled_key_input(event: InputEvent) -> void: redo() get_viewport().set_input_as_handled() return + if key.keycode == KEY_ESCAPE: + clear_selection() + get_viewport().set_input_as_handled() + return if key.keycode != KEY_DELETE and key.keycode != KEY_BACKSPACE: return @@ -1190,6 +1270,7 @@ func _setup_timing_controls() -> void: func _set_timing_controls_enabled(enabled: bool) -> void: + label_button.disabled = not enabled duration_minus_button.disabled = not enabled duration_plus_button.disabled = not enabled speed_minus_button.disabled = not enabled @@ -1202,6 +1283,7 @@ func _update_timing_ui() -> void: var selected := get_selected_segment() if selected == null: timing_selection_label.text = "Kein Segment ausgewählt" + label_button.tooltip_text = "Beschriftung für das ausgewählte Segment" duration_value_label.text = "…" speed_value_label.text = "…" _set_timing_controls_enabled(false) @@ -1209,6 +1291,12 @@ func _update_timing_ui() -> void: return _set_timing_controls_enabled(true) + var label_text := selected.label.strip_edges() + label_button.tooltip_text = ( + "Beschriftung bearbeiten: %s" % label_text + if not label_text.is_empty() + else "Beschriftung für das ausgewählte Segment" + ) var kind := "Bogen" if selected.is_arc() else "Linie" timing_selection_label.text = "%s · %s m" % [ kind, @@ -1945,6 +2033,9 @@ func _update_status() -> void: direction_word, edge_word, ] + var segment_label := selected.label.strip_edges() + if not segment_label.is_empty(): + text += ' · „%s“' % segment_label status_label.text = text return diff --git a/rinkplanner/src/whiteboard/io/export_sheet.gd b/rinkplanner/src/whiteboard/io/export_sheet.gd index dbf122a..a90ebd0 100644 --- a/rinkplanner/src/whiteboard/io/export_sheet.gd +++ b/rinkplanner/src/whiteboard/io/export_sheet.gd @@ -34,6 +34,7 @@ func setup(routine: Routine, section_id: String = "") -> void: subtitle_label.text = "" export_canvas.fit_padding_px = 24.0 + export_canvas.set_labels_visible(true) export_canvas.set_presentation_mode(true) export_canvas.set_presentation_section_filter(section_id) export_canvas.set_routine(routine) diff --git a/rinkplanner/src/whiteboard/io/svg_exporter.gd b/rinkplanner/src/whiteboard/io/svg_exporter.gd index 2abf711..fa68988 100644 --- a/rinkplanner/src/whiteboard/io/svg_exporter.gd +++ b/rinkplanner/src/whiteboard/io/svg_exporter.gd @@ -139,6 +139,7 @@ static func build(routine: Routine, section_id: String = "") -> String: ] ) + _add_segment_labels(lines, sections, scale, center) _add_section_badges(lines, sections, scale, center) lines.append( @@ -203,6 +204,40 @@ static func _add_section_badges( ) + +## Free-text labels of all drawn segments. A white outline (paint-order: +## stroke) keeps them readable on top of the ice and the path lines. +static func _add_segment_labels( + lines: PackedStringArray, + sections: Array[RoutineSection], + scale: float, + center: Vector2 +) -> void: + for section: RoutineSection in sections: + for segment: PathSegment in section.segments: + if segment == null or segment.curve == null: + continue + var text := segment.label.strip_edges() + if text.is_empty(): + continue + var length := segment.curve.get_baked_length() + if length <= 0.0: + continue + var mid := segment.curve.sample_baked(length * 0.5) + var ahead := segment.curve.sample_baked( + minf(length, length * 0.5 + 0.5) + ) + var tangent := ahead - mid + if tangent.length_squared() < 0.0001: + tangent = Vector2.RIGHT + var normal := Vector2(-tangent.y, tangent.x).normalized() + var point := center + mid * scale + normal * 15.0 + lines.append( + '%s' + % [_n(point.x), _n(point.y), TEXT_COLOR, _escape(text)] + ) + + static func _sample_curve(curve: Curve2D) -> PackedVector2Array: var length := curve.get_baked_length() if length <= 0.0: diff --git a/rinkplanner/src/whiteboard/view/rink_canvas.gd b/rinkplanner/src/whiteboard/view/rink_canvas.gd index 407e0f8..25458c3 100644 --- a/rinkplanner/src/whiteboard/view/rink_canvas.gd +++ b/rinkplanner/src/whiteboard/view/rink_canvas.gd @@ -35,6 +35,9 @@ const SELECTION_HALO_COLOR := Color(1.0, 1.0, 1.0, 0.5) const HANDLE_FILL_COLOR := Color("#f8fafc") const HANDLE_BORDER_COLOR := Color("#0f172a") const BULGE_HANDLE_COLOR := Color("#f59e0b") +const LABEL_TEXT_COLOR := Color("#f8fafc") +const LABEL_BACKGROUND_COLOR := Color(0.043, 0.071, 0.129, 0.86) +const LABEL_BORDER_COLOR := Color(0.31, 0.38, 0.49, 0.9) const OUTLINE_ARC_SEGMENTS := 12 const CENTER_CIRCLE_RADIUS_M := 4.5 const CENTER_CIRCLE_SEGMENTS := 64 @@ -50,6 +53,7 @@ const TOUCH_MOUSE_GUARD_MSEC := 300 @export var fit_padding_px: float = 32.0 @export var drawing_enabled: bool = true @export var presentation_mode: bool = false +@export var labels_visible: bool = true var _presentation_section_filter: String = "" @@ -100,6 +104,13 @@ func _notification(what: int) -> void: fit_rink() +func set_labels_visible(visible: bool) -> void: + if labels_visible == visible: + return + labels_visible = visible + queue_redraw() + + func set_rink(rink: RinkDimensions) -> void: _rink = rink fit_rink() @@ -298,6 +309,8 @@ func _draw_routine() -> void: ): continue _draw_section(section, 1.0) + if labels_visible: + _draw_section_labels(section) return var highlight_id := _active_section_id @@ -312,6 +325,8 @@ func _draw_routine() -> void: var highlighted := _get_section_by_id(highlight_id) if highlighted != null: _draw_section(highlighted, 1.0) + if labels_visible: + _draw_section_labels(highlighted) func _draw_section_badges() -> void: @@ -400,6 +415,85 @@ func _draw_section(section: RoutineSection, alpha: float) -> void: _draw_segment(segment, alpha, step_px) +## Free-text labels sit next to the middle of their segment. Only the active +## section (or all sections in presentation mode) is labelled; ghosted +## sections are already too faint for readable text. +func _draw_section_labels(section: RoutineSection) -> void: + for segment: PathSegment in section.segments: + if segment == null or segment.curve == null: + continue + if segment.label.strip_edges().is_empty(): + continue + _draw_segment_label(segment, segment.segment_id == _selected_segment_id) + + +func _draw_segment_label(segment: PathSegment, selected: bool = false) -> void: + var length := segment.get_length_m() + if length <= 0.0: + return + + var mid_model := segment.curve.sample_baked(length * 0.5) + var ahead_model := segment.curve.sample_baked(minf(length, length * 0.5 + 0.5)) + var mid := _transform.model_to_screen(mid_model) + var ahead := _transform.model_to_screen(ahead_model) + + var tangent := ahead - mid + if tangent.length_squared() < 0.0001: + tangent = Vector2.RIGHT + var normal := Vector2(-tangent.y, tangent.x).normalized() + + var text := segment.label.strip_edges() + var font := ThemeDB.fallback_font + var font_size := 14 + var text_size := font.get_string_size( + text, HORIZONTAL_ALIGNMENT_LEFT, -1, font_size + ) + var ascent := font.get_ascent(font_size) + var descent := font.get_descent(font_size) + var padding := Vector2(7.0, 3.0) + var box_size := Vector2( + text_size.x + padding.x * 2.0, + ascent + descent + padding.y * 2.0 + ) + + # Prefer the side with more room, so labels near the boards stay visible. + var center := mid + normal * (0.5 * _segment_width() + 14.0 + box_size.y * 0.5) + if ( + center.x - box_size.x * 0.5 < 2.0 + or center.x + box_size.x * 0.5 > size.x - 2.0 + or center.y - box_size.y * 0.5 < 2.0 + or center.y + box_size.y * 0.5 > size.y - 2.0 + ): + center = mid - normal * (0.5 * _segment_width() + 14.0 + box_size.y * 0.5) + + if ( + center.x + box_size.x * 0.5 < 0.0 + or center.x - box_size.x * 0.5 > size.x + or center.y + box_size.y * 0.5 < 0.0 + or center.y - box_size.y * 0.5 > size.y + ): + return + + var box := Rect2(center - box_size * 0.5, box_size) + draw_rect(box, LABEL_BACKGROUND_COLOR, true) + draw_rect( + box, + BULGE_HANDLE_COLOR if selected else LABEL_BORDER_COLOR, + false, + 2.0 if selected else 1.0 + ) + var baseline := center.y + (ascent - descent) * 0.5 + draw_string( + font, + Vector2(center.x - text_size.x * 0.5, baseline), + text, + HORIZONTAL_ALIGNMENT_LEFT, + -1, + font_size, + LABEL_TEXT_COLOR + ) + + func _draw_segment( segment: PathSegment, alpha: float, diff --git a/rinkplanner/tests/manual/capture_labels.gd b/rinkplanner/tests/manual/capture_labels.gd new file mode 100644 index 0000000..80c9cca --- /dev/null +++ b/rinkplanner/tests/manual/capture_labels.gd @@ -0,0 +1,60 @@ +extends SceneTree + +## Manual visual smoke test for segment labels. +## +## Usage: +## xvfb-run -a godot --path rinkplanner \ +## --script res://tests/manual/capture_labels.gd -- 1400 876 /tmp/labels.png + +func _init() -> void: + _capture.call_deferred() + + +func _capture() -> void: + var args := OS.get_cmdline_user_args() + var width := int(args[0]) if args.size() > 0 else 1400 + var height := int(args[1]) if args.size() > 1 else 876 + var output := args[2] if args.size() > 2 else "user://capture_labels.png" + + var packed := load("res://scenes/whiteboard/whiteboard.tscn") as PackedScene + var controller := packed.instantiate() as WhiteboardController + controller.restore_autosave = false + controller.autosave_enabled = false + root.add_child(controller) + root.size = Vector2i(width, height) + await process_frame + await process_frame + + var labels := [ + ["Eingang", Vector2(-24.0, -12.0), Vector2(-14.0, -12.0), Tool_LINE], + ["3Lz", Vector2(-12.0, -12.0), Vector2(-2.0, -6.0), Tool_LINE], + ["Choreo", Vector2(-2.0, -6.0), Vector2(12.0, -6.0), Tool_ARC], + ["Pirouette", Vector2(14.0, 2.0), Vector2(18.0, 8.0), Tool_LINE], + ] + for entry: Array in labels: + var segment := controller.add_segment( + entry[1], entry[2], PathSegment.Direction.FORWARD, + PathSegment.Edge.OUTSIDE, entry[3] + ) + segment.label = entry[0] + + controller.set_active_section(controller.get_active_section().section_id) + if args.size() > 3 and args[3] in ["select", "dialog"]: + var segments := controller.get_active_section().segments + controller.select_segment(segments[segments.size() - 1].segment_id) + if args.size() > 3 and args[3] == "dialog": + controller.label_button.pressed.emit() + controller.rink_canvas.fit_rink() + controller.rink_canvas.refresh() + await process_frame + await process_frame + await RenderingServer.frame_post_draw + + var path := ProjectSettings.globalize_path(output) + root.get_texture().get_image().save_png(path) + print("Saved %s at %dx%d" % [path, width, height]) + quit(0) + + +const Tool_LINE := WhiteboardController.Tool.LINE +const Tool_ARC := WhiteboardController.Tool.ARC_LEFT diff --git a/rinkplanner/tests/manual/capture_labels.gd.uid b/rinkplanner/tests/manual/capture_labels.gd.uid new file mode 100644 index 0000000..747a521 --- /dev/null +++ b/rinkplanner/tests/manual/capture_labels.gd.uid @@ -0,0 +1 @@ +uid://bgo5ewh7x1288 diff --git a/rinkplanner/tests/run_export_tests.gd b/rinkplanner/tests/run_export_tests.gd index 8fdf559..0925943 100644 --- a/rinkplanner/tests/run_export_tests.gd +++ b/rinkplanner/tests/run_export_tests.gd @@ -29,6 +29,14 @@ func _run() -> void: _check(svg.contains("#2563EB"), "SVG contains inside-edge color") _check(svg.contains("stroke-dasharray="), "SVG encodes backward segments as dashes") _check(_count(svg, "3Lz & <Spin>"), + "SVG contains and escapes segment labels" + ) + _check( + svg.contains('paint-order="stroke"'), + "SVG labels get a white outline" + ) var section_svg := RoutineSvgExporter.build(routine, "section-1") _check( @@ -91,14 +99,16 @@ func _make_routine() -> Routine: section_one.section_id = "section-1" section_one.title = "Abschnitt 1" section_one.sequence_order = 0 + var labelled := _make_segment( + "seg-1", + Vector2(-20.0, -8.0), + Vector2(-10.0, -8.0), + PathSegment.Direction.FORWARD, + PathSegment.Edge.OUTSIDE + ) + labelled.label = "3Lz & " section_one.segments = [ - _make_segment( - "seg-1", - Vector2(-20.0, -8.0), - Vector2(-10.0, -8.0), - PathSegment.Direction.FORWARD, - PathSegment.Edge.OUTSIDE - ), + labelled, _make_segment( "seg-2", Vector2(-10.0, -8.0), diff --git a/rinkplanner/tests/run_history_tests.gd b/rinkplanner/tests/run_history_tests.gd index af57c56..33a13b2 100644 --- a/rinkplanner/tests/run_history_tests.gd +++ b/rinkplanner/tests/run_history_tests.gd @@ -199,6 +199,30 @@ func _run() -> void: "redo reapplies the arc start" ) + controller.select_segment(arc.segment_id) + _check( + controller.get_selected_segment() != null, + "segment can be selected for labelling" + ) + controller.set_selected_segment_label("Eingang") + var labelled := controller.get_selected_segment() + _check( + labelled != null and labelled.label == "Eingang", + "label edit is applied" + ) + _check(controller.undo(), "undo label edit") + var unlabelled := controller.get_active_section().get_segment_by_id(arc.segment_id) + _check( + unlabelled != null and unlabelled.label.is_empty(), + "undo clears the label" + ) + _check(controller.redo(), "redo label edit") + var relabelled := controller.get_active_section().get_segment_by_id(arc.segment_id) + _check( + relabelled != null and relabelled.label == "Eingang", + "redo restores the label" + ) + controller.new_routine() _check(controller.undo_button.disabled, "new routine clears undo history") _check(controller.redo_button.disabled, "new routine clears redo history") diff --git a/rinkplanner/tests/run_whiteboard_tests.gd b/rinkplanner/tests/run_whiteboard_tests.gd index 0671307..8e86a5c 100644 --- a/rinkplanner/tests/run_whiteboard_tests.gd +++ b/rinkplanner/tests/run_whiteboard_tests.gd @@ -540,6 +540,85 @@ func _run() -> void: "rename dialog applies the edited title" ) + # Segment labels. + controller.select_segment(arc_left.segment_id) + _check( + not controller.label_button.disabled, + "label button is enabled with a selection" + ) + _check( + controller.get_selected_segment_label().is_empty(), + "segments start without a label" + ) + _check( + controller.set_selected_segment_label(" Eingang "), + "label can be set" + ) + _check( + controller.get_selected_segment_label() == "Eingang", + "label is trimmed" + ) + _check(controller.is_dirty(), "label edit marks the routine dirty") + _check( + not controller.set_selected_segment_label("Eingang"), + "unchanged label records no history" + ) + _check(controller.are_labels_visible(), "labels are visible by default") + _check( + controller.labels_toggle.button_pressed, + "labels toggle starts pressed" + ) + controller.set_labels_visible(false) + _check(not controller.are_labels_visible(), "labels can be hidden") + _check( + not controller.labels_toggle.button_pressed, + "toggle reflects hidden labels" + ) + controller.set_labels_visible(true) + _check(controller.are_labels_visible(), "labels can be shown again") + _check( + controller.labels_toggle.button_pressed, + "toggle reflects visible labels" + ) + controller.clear_selection() + _check( + controller.get_selected_segment() == null, + "clear_selection removes the selection" + ) + _check( + controller.label_button.disabled, + "label button is disabled without a selection" + ) + controller.select_segment(arc_left.segment_id) + _check( + controller.label_button.disabled == false, + "label button is enabled again after selecting" + ) + controller.label_button.pressed.emit() + _check( + controller.segment_label_dialog.visible, + "label button opens the label dialog" + ) + _check( + controller.segment_label_edit.text == "Eingang", + "label dialog is prefilled" + ) + controller.segment_label_edit.text = "Ausgang" + controller.segment_label_dialog.confirmed.emit() + _check( + controller.get_selected_segment_label() == "Ausgang", + "label dialog applies the edited text" + ) + controller.segment_label_edit.text = "" + controller.segment_label_dialog.confirmed.emit() + _check( + controller.get_selected_segment_label().is_empty(), + "empty text removes the label" + ) + controller.segment_label_dialog.hide() + controller.set_selected_segment_label("Eingang") + var saved_label := controller.get_selected_segment_label() + # Save/load round-trip. var roundtrip_path := "user://test_roundtrip.tres" var saved_section_title := controller.get_active_section().title @@ -595,6 +674,10 @@ func _run() -> void: loaded_arc.curve.point_count > 2, "load restores the sampled arc curve" ) + _check( + loaded_arc.label == saved_label, + "load restores the segment label" + ) DirAccess.remove_absolute(roundtrip_path)