oak-gpui/crates/gpui/examples/learn/effect_stack.rs

//! Intended-usage sketch of the `gpui::effect_stack` widget.
//!
//! Builds a mock stack (Media → Transform → OCIO LUT → Output), hosts an
//! [`EffectStackView`], and logs every edit request it emits. The mock data
//! source simply applies requests in place and calls `cx.notify()`; a real
//! app (Oak) would route them through its engine and undo stack.
//!
//! NOTE: the widget implementation itself is still a skeleton (`todo!()`),
//! so this example compiles but does not render yet.

// The modules under demo are skeletons whose bodies are `todo!()` by design.
#![allow(clippy::todo)]

#[path = "../shared/prelude.rs"]
mod example_prelude;

use std::sync::Arc;

use example_prelude::init_example;
use gpui::effect_stack::{
	EffectCardKind, EffectData, EffectId, EffectStackDataSource, EffectStackEvent, EffectStackView,
};
use gpui::{
	App, Bounds, Context, Entity, Render, SharedString, Window, WindowBounds, WindowOptions, div,
	prelude::*, px, size,
};

// ---------------------------------------------------------------------------
// Mock model
// ---------------------------------------------------------------------------

struct MockEffect {
	id: EffectId,
	kind: EffectCardKind,
	title: String,
	subtitle: Option<String>,
	enabled: bool,
	expanded: bool,
	badge: Option<usize>,
}

impl EffectData for MockEffect {
	fn id(&self) -> EffectId {
		self.id
	}
	fn kind(&self) -> EffectCardKind {
		self.kind
	}
	fn title(&self) -> SharedString {
		self.title.clone().into()
	}
	fn subtitle(&self) -> Option<SharedString> {
		self.subtitle.clone().map(Into::into)
	}
	fn is_enabled(&self) -> bool {
		self.enabled
	}
	fn is_expanded(&self) -> bool {
		self.expanded
	}
	fn badge_count(&self) -> Option<usize> {
		self.badge
	}
}

/// The mock data source. In Oak this would be a view-model entity deriving
/// the ordered card list from the node-graph path of the selected clip.
struct MockStack {
	clip_name: String,
	effects: Vec<MockEffect>,
	/// Reserved for allocating ids to effects added at runtime.
	#[allow(dead_code)]
	next_id: u64,
}

impl MockStack {
	fn demo() -> Self {
		Self {
			clip_name: "A001_C002_0103.mov".to_string(),
			effects: vec![
				MockEffect {
					id: EffectId(0),
					kind: EffectCardKind::Source,
					title: "Media".into(),
					subtitle: Some("A001_C002_0103.mov".into()),
					enabled: true,
					expanded: false,
					badge: None,
				},
				MockEffect {
					id: EffectId(1),
					kind: EffectCardKind::Effect,
					title: "Transform".into(),
					subtitle: Some("scale 100%, rotate 0°".into()),
					enabled: true,
					expanded: true,
					badge: Some(2),
				},
				MockEffect {
					id: EffectId(2),
					kind: EffectCardKind::Effect,
					title: "OCIO LUT".into(),
					subtitle: Some("filmic_to_display.cube".into()),
					enabled: true,
					expanded: false,
					badge: None,
				},
				MockEffect {
					id: EffectId(3),
					kind: EffectCardKind::Output,
					title: "Output".into(),
					subtitle: None,
					enabled: true,
					expanded: false,
					badge: None,
				},
			],
			next_id: 4,
		}
	}
}

impl EffectStackDataSource for MockStack {
	fn effects(&self) -> Vec<Arc<dyn EffectData>> {
		self.effects
			.iter()
			.map(|effect| {
				Arc::new(MockEffect {
					id: effect.id,
					kind: effect.kind,
					title: effect.title.clone(),
					subtitle: effect.subtitle.clone(),
					enabled: effect.enabled,
					expanded: effect.expanded,
					badge: effect.badge,
				}) as Arc<dyn EffectData>
			})
			.collect()
	}

	fn target_label(&self) -> Option<SharedString> {
		Some(self.clip_name.clone().into())
	}
}

// ---------------------------------------------------------------------------
// Root view: hosts the stack and applies edit requests to the mock model.
// ---------------------------------------------------------------------------

/// Placeholder parameter view. A real app builds the effect's controls here
/// and calls [`EffectStackView::notify_parameter_changed`] after edits.
struct MockParams {
	effect: EffectId,
}

impl Render for MockParams {
	fn render(&mut self, _window: &mut Window, _cx: &mut Context<Self>) -> impl IntoElement {
		div().child(format!("parameters for {} (mock)", self.effect))
	}
}

struct StackDemoRoot {
	data: Entity<MockStack>,
	stack: Entity<EffectStackView<MockStack>>,
}

impl StackDemoRoot {
	fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
		let data = cx.new(|_cx| MockStack::demo());

		let stack = cx.new(|cx| {
			EffectStackView::new(data.clone(), cx).params_renderer(|id, _window, cx| {
				// Real apps build the effect's parameter controls here. The
				// mock just shows a placeholder label.
				cx.new(|_cx| MockParams { effect: *id }).into()
			})
		});

		// The "edits are requests" loop: log each request, apply it to the
		// model (Oak: engine command + undo), then notify.
		cx.subscribe_in(&stack, window, {
			let data = data.clone();
			move |_root, _stack, event: &EffectStackEvent, _window, cx| {
				println!("[effect_stack] request: {event:?}");
				data.update(cx, |data, cx| {
					match event {
						EffectStackEvent::EnableToggled { effect, enabled } => {
							if let Some(e) = data.effects.iter_mut().find(|e| e.id == *effect) {
								e.enabled = *enabled;
							}
						}
						EffectStackEvent::ExpansionToggled { effect, expanded } => {
							if let Some(e) = data.effects.iter_mut().find(|e| e.id == *effect) {
								e.expanded = *expanded;
							}
						}
						EffectStackEvent::ReorderRequested { .. }
						| EffectStackEvent::RemoveRequested(_)
						| EffectStackEvent::AddRequested { .. }
						| EffectStackEvent::ContextMenuRequested { .. }
						| EffectStackEvent::ParameterChanged { .. } => {
							todo!("apply {event:?} to the mock model (or engine, in a real app)")
						}
					}
					cx.notify();
				});
			}
		})
		.detach();

		Self { data, stack }
	}
}

impl Render for StackDemoRoot {
	fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
		let _ = &self.data;
		let _ = cx;
		div()
			.size_full()
			.flex()
			.items_center()
			.justify_center()
			.child(self.stack.clone())
	}
}

fn main() {
	gpui_platform::application().run(|cx: &mut App| {
		init_example(cx, "Effect Stack");

		let bounds = Bounds::centered(None, size(px(420.0), px(640.0)), cx);
		cx.open_window(
			WindowOptions {
				window_bounds: Some(WindowBounds::Windowed(bounds)),
				..Default::default()
			},
			|window, cx| cx.new(|cx| StackDemoRoot::new(window, cx)),
		)
		.unwrap();
	});
}