Struct LegacyTimeline 

pub struct LegacyTimeline<T: Timeline + Send> { /* private fields */ }

Adapts an old closure-based Timeline to the new TimelineComponent model so the existing demo scene (which still builds a Timeline) can be served by the migrated collection without rewriting it.

A Timeline is opaque (a closure with a fixed duration), so this presents it as a single timed leaf: its frame plays the timeline at the global clock, its length is the timeline’s duration, and its arrangement is one Video-kind node spanning [0, duration].

TimelineComponent requires PartialEq + Hash (via the DynEq/DynHash super-traits). A Timeline closure is neither, and timeline nodes are never memoized through ctx.render (.sketch/02 §11) — this identity is only the builder-marker key — so the wrapper compares all instances equal and hashes to a constant. There is exactly one per collection, so that is sound.

Implementations

impl<T: Timeline + Send> LegacyTimeline<T>

pub fn new(timeline: T) -> Self

Wraps timeline so it can be placed in the new timeline world.

Trait Implementations

impl<T: Timeline + Send> Eq for LegacyTimeline<T>

impl<T: Timeline + Send> Hash for LegacyTimeline<T>

fn hash<H: Hasher>(&self, _state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: Timeline + Send> PartialEq for LegacyTimeline<T>

fn eq(&self, _other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Timeline + Send + 'static> TimelineComponent for LegacyTimeline<T>

fn duration(&self) -> Option<f32>

Intrinsic length in seconds, or None for a timeless component (a visual / 字幕) whose length is given by the window it is placed into.

fn frame( &self, clock: Clock<'_>, canvas: Vec2, target: Resolution, ctx: &mut dyn RenderContext, ) -> Option<RasterImage>

Visual channel for this frame. clock carries both time axes (see Clock); canvas is the composition’s fixed LOGICAL layout space (resolution-independent), which the pixel target scales. None ⇒ contributes nothing visually.

fn arrangement(&self, offset: f32) -> Arrangement

What the live UI draws: kind + label, plus the node’s RESOLVED absolute interval and any Event trigger times.

fn measure(&self) -> Option<f32>

Bottom-up intrinsic duration for the resolve pass’s measure phase (.sketch/02 §5). Defaults to duration; containers override to fold over their children.

fn resolve(&self, abs_start: f32, out: &mut ResolveCtx) -> f32

Top-down place hook (.sketch/02 §6). Walks self and, for a container, recurses over its OWN children via &self recursion — assigning each an absolute start and recording Event trigger times into out — returning this node’s resolved length.

fn samples(&self, clock: Clock<'_>, window: f32) -> Option<AudioBuffer>

Audio channel for [clock, clock + window). None ⇒ silent.

fn mix_into(&self, mix: &mut AudioMix, start_secs: f32, speed: f32)

Eager mix-down hook (step 8, B4 v1 — .sketch/01 ZONE C / .sketch/02 §15). Contributes this node’s audio into mix (a fixed rate / channel layout buffer for [0, duration]), placing it at the absolute start_secs and accounting for the accumulated placement speed.

fn cues(&self, offset: f32) -> Vec<Cue>

Subtitle channel: cues made absolute by adding offset (this component’s resolved start). Collected once at export.

fn structural_any(&self) -> &(dyn Any + 'static)

The STRUCTURAL &dyn Any behind this component, peeling any transparent decorator. A container inspecting a child’s concrete type (e.g. downcasting to Placed to detect a .fill()) must go through this, not DynEq::as_any, so a wrapping Sourced (which the generated .child(...) setter adds to capture the call site) does not hide the real child. Defaults to self — only a decorator like Sourced overrides it to forward to its inner component.