Open source Loom alternative. Beautiful, shareable screen recordings.
Rust appcapcossloommacnextjsnextjs15open-sourceossreactrecordrustscreen-capturescreen-recorderscreenshotsolidjstauritauri-apptypescriptvite
use cap_project::{
BackgroundConfiguration, FrameConfiguration, FrameStyle, FrameTheme, ProjectConfiguration,
};
use gpui::{
AppContext as _, Context, Entity, FontWeight, InteractiveElement, IntoElement, MouseButton,
ParentElement, StatefulInteractiveElement as _, Styled, Window, div, point,
prelude::FluentBuilder, px, svg,
};
use super::EditorWindow;
use crate::ui;
const FRAME_STYLES: [(FrameStyle, &str, &str, &str); 5] = [
(
FrameStyle::None,
"None",
"Show the recording as-is",
"icons/ban.svg",
),
(
FrameStyle::MacOS,
"macOS",
"Window chrome with traffic lights",
"icons/app-window-mac.svg",
),
(
FrameStyle::Windows,
"Windows",
"Title bar with window controls",
"icons/app-window.svg",
),
(
FrameStyle::Browser,
"Browser",
"Browser chrome with address bar",
"icons/globe.svg",
),
(
FrameStyle::Macbook,
"MacBook",
"Laptop bezel around the recording",
"icons/laptop.svg",
),
];
#[derive(Default)]
pub(super) struct FrameControls {
open: bool,
trigger_bounds: ui::SliderTrack,
fields: Option<[Entity<ui::TextInputState>; 2]>,
editing: Option<FrameField>,
style_target: Option<StyleFrameTarget>,
}
struct StyleFrameTarget {
index: usize,
fingerprint: String,
}
impl StyleFrameTarget {
fn capture(project: &ProjectConfiguration, index: usize) -> Option<Self> {
let segment = project.timeline.as_ref()?.style_segments.get(index)?;
Some(Self {
index,
fingerprint: serde_json::to_string(segment).ok()?,
})
}
fn matches(&self, project: &ProjectConfiguration) -> bool {
Self::capture(project, self.index)
.is_some_and(|target| target.fingerprint == self.fingerprint)
}
}
impl FrameControls {
pub(super) fn is_open(&self) -> bool {
self.open
}
}
#[derive(Clone, Copy, PartialEq, Eq)]
enum FrameField {
Url,
Title,
}
impl FrameField {
fn for_style(style: FrameStyle) -> Option<Self> {
match style {
FrameStyle::Browser => Some(Self::Url),
FrameStyle::MacOS => Some(Self::Title),
_ => None,
}
}
fn index(self) -> usize {
match self {
Self::Url => 0,
Self::Title => 1,
}
}
fn label(self) -> &'static str {
match self {
Self::Url => "URL",
Self::Title => "Title",
}
}
fn text(self, frame: &FrameConfiguration) -> &str {
match self {
Self::Url => &frame.url,
Self::Title => &frame.title,
}
}
}
enum FrameChange {
Style(FrameStyle),
Theme(FrameTheme),
Text(FrameField, String),
}
fn apply_frame_change(project: &mut ProjectConfiguration, change: FrameChange) -> bool {
apply_background_frame_change(&mut project.background, change)
}
fn apply_background_frame_change(
background: &mut BackgroundConfiguration,
change: FrameChange,
) -> bool {
let previous = background.frame.clone();
let frame = background.frame.get_or_insert_with(Default::default);
match change {
FrameChange::Style(style) => frame.style = style,
FrameChange::Theme(theme) => frame.theme = theme,
FrameChange::Text(FrameField::Url, text) => frame.url = text,
FrameChange::Text(FrameField::Title, text) => frame.title = text,
}
background.frame != previous
}
fn apply_targeted_frame_change(
project: &mut ProjectConfiguration,
target: Option<&StyleFrameTarget>,
change: FrameChange,
) -> bool {
let Some(target) = target else {
return apply_frame_change(project, change);
};
if !target.matches(project) {
return false;
}
let Some(segment) = project
.timeline
.as_mut()
.and_then(|timeline| timeline.style_segments.get_mut(target.index))
else {
return false;
};
// The edit only ever touches the background, so clone that rather than the
// whole project: the text fields send one of these per keystroke.
let mut background = segment
.overrides
.background
.clone()
.unwrap_or_else(|| project.background.clone());
if !apply_background_frame_change(&mut background, change) {
return false;
}
segment.overrides.background = Some(background);
true
}
fn button_content(style: FrameStyle) -> (&'static str, &'static str) {
if style == FrameStyle::None {
return ("Frame", "icons/app-window-mac.svg");
}
FRAME_STYLES
.iter()
.find(|option| option.0 == style)
.map(|option| (option.1, option.3))
.unwrap_or(("Frame", "icons/app-window-mac.svg"))
}
impl EditorWindow {
fn frame_background(&self) -> &cap_project::BackgroundConfiguration {
let index = if self.frame_controls.open {
self.frame_controls
.style_target
.as_ref()
.map(|target| target.index)
} else {
self.selected_style_index()
};
index
.and_then(|index| {
self.project
.timeline
.as_ref()?
.style_segments
.get(index)?
.overrides
.background
.as_ref()
})
.unwrap_or(&self.project.background)
}
pub(crate) fn dismiss_frame_controls(&mut self, cx: &mut Context<Self>) {
self.finish_frame_text_edit(cx);
self.frame_controls.open = false;
self.frame_controls.style_target = None;
}
fn edit_frame(&mut self, change: FrameChange, window: &mut Window, cx: &mut Context<Self>) {
if !self.frame_controls.open {
return;
}
if !apply_targeted_frame_change(
&mut self.project,
self.frame_controls.style_target.as_ref(),
change,
) {
return;
}
if let Some(target) = &mut self.frame_controls.style_target
&& let Some(next) = StyleFrameTarget::capture(&self.project, target.index)
{
*target = next;
}
self.project_changed_without_timeline(window, cx);
}
fn frame_style(&self) -> FrameStyle {
FrameConfiguration::active_style(self.frame_background().frame.as_ref())
}
pub(super) fn render_frame_button(
&self,
narrow: bool,
cx: &mut Context<Self>,
) -> impl IntoElement {
let (label, icon) = button_content(self.frame_style());
let bounds = self.frame_controls.trigger_bounds.clone();
div()
.relative()
.flex_none()
.child(
ui::EditorButton::plain(&self.theme, "frame-settings")
.text(&self.theme)
.left_icon(icon)
.right_icon("icons/chevron-down.svg")
.when(!narrow, |button| button.label(label))
.tooltip(&self.theme, "Add a frame")
.pressed(self.frame_controls.open)
.disabled(self.instance.is_none())
.on_click(cx.listener(|this, _, window, cx| {
if this.frame_controls.open {
this.close_frame_controls(window, cx);
} else {
this.focus_root(window, cx);
this.toolbar_menu = None;
this.add_track = None;
this.frame_controls.style_target = this
.selected_style_index()
.and_then(|index| StyleFrameTarget::capture(&this.project, index));
this.frame_controls.open = true;
cx.notify();
}
})),
)
.child(
gpui::canvas(move |rect, _, _| bounds.set(Some(rect)), |_, _, _, _| {})
.absolute()
.top_0()
.left_0()
.size_full(),
)
}
pub(super) fn prepare_frame_fields(&mut self, window: &mut Window, cx: &mut Context<Self>) {
if !self.frame_controls.open {
return;
}
if self.frame_controls.fields.is_none() {
self.frame_controls.fields = Some([FrameField::Url, FrameField::Title].map(|field| {
let input = cx.new(|cx| {
let mut input = ui::TextInputState::single_line(window, cx);
input.set_placeholder(match field {
FrameField::Url => "cap.so",
FrameField::Title => "Window title",
});
input
});
let subscription =
cx.subscribe_in(&input, window, move |this, input, event, window, cx| {
this.on_frame_field_event(field, input, event, window, cx);
});
self.push_text_subscription(subscription);
input
}));
}
let frame = self.frame_background().frame.clone().unwrap_or_default();
if let Some(inputs) = &self.frame_controls.fields {
for field in [FrameField::Url, FrameField::Title] {
let input = &inputs[field.index()];
if !input.read(cx).focus_handle().is_focused(window) {
input.update(cx, |input, cx| {
input.set_text(field.text(&frame).to_owned(), cx)
});
}
}
}
}
fn on_frame_field_event(
&mut self,
field: FrameField,
input: &Entity<ui::TextInputState>,
event: &ui::TextInputEvent,
window: &mut Window,
cx: &mut Context<Self>,
) {
match event {
ui::TextInputEvent::Changed => {
if !self.frame_controls.open
|| FrameField::for_style(self.frame_style()) != Some(field)
{
return;
}
if self.frame_controls.editing != Some(field) {
self.finish_frame_text_edit(cx);
self.history.pause();
self.frame_controls.editing = Some(field);
}
let change = FrameChange::Text(field, input.read(cx).text().to_owned());
self.edit_frame(change, window, cx);
}
ui::TextInputEvent::Blurred => self.finish_frame_text_edit(cx),
ui::TextInputEvent::Confirmed => {
self.finish_frame_text_edit(cx);
self.focus_root(window, cx);
}
ui::TextInputEvent::Cancelled => self.close_frame_controls(window, cx),
}
}
fn finish_frame_text_edit(&mut self, cx: &mut Context<Self>) {
if self.frame_controls.editing.take().is_some() {
self.history.resume(&self.project);
cx.notify();
}
}
pub(super) fn close_frame_controls(&mut self, window: &mut Window, cx: &mut Context<Self>) {
self.finish_frame_text_edit(cx);
self.frame_controls.open = false;
self.frame_controls.style_target = None;
self.focus_root(window, cx);
cx.notify();
}
fn change_frame(&mut self, change: FrameChange, window: &mut Window, cx: &mut Context<Self>) {
self.finish_frame_text_edit(cx);
self.focus_root(window, cx);
self.edit_frame(change, window, cx);
}
pub(super) fn render_frame_controls(
&self,
window: &Window,
cx: &mut Context<Self>,
) -> Option<gpui::AnyElement> {
if !self.frame_controls.open {
return None;
}
let bounds = self.frame_controls.trigger_bounds.get()?;
let theme = self.theme;
let style = self.frame_style();
let frame_theme = self
.frame_background()
.frame
.as_ref()
.map_or(FrameTheme::Dark, |frame| frame.theme);
let panel = div()
.id("frame-popover")
.occlude()
.flex()
.flex_col()
.w(px(304.).min(window.viewport_size().width - px(24.)))
.max_h(
(window.viewport_size().height - bounds.bottom() - px(20.))
.min(window.viewport_size().height - px(24.)),
)
.overflow_y_scroll()
.rounded(px(12.))
.border_1()
.border_color(gpui::Hsla::from(theme.editor.line))
.bg(gpui::Hsla::from(theme.editor.card))
.shadow(theme.editor.pop_shadow())
.on_mouse_down(MouseButton::Left, |_, _, cx| cx.stop_propagation())
.child(
div()
.flex()
.flex_col()
.gap(px(2.))
.px(px(16.))
.pt(px(14.))
.pb(px(12.))
.border_b_1()
.border_color(theme.gray(3))
.child(
div()
.text_size(px(13.))
.font_weight(FontWeight::SEMIBOLD)
.text_color(theme.gray(12))
.child("Frame"),
)
.child(
div().text_size(px(11.)).text_color(theme.gray(10)).child(
match &self.frame_controls.style_target {
Some(target) if !target.matches(&self.project) => {
"This Style changed. Close and reopen Frame.".to_string()
}
Some(target)
if self
.project
.timeline
.as_ref()
.and_then(|timeline| {
timeline.style_segments.get(target.index)
})
.is_some_and(|segment| {
segment.overrides.background.is_none()
}) =>
{
format!(
"Style {} only · Editing enables its background override.",
target.index + 1
)
}
Some(target) => format!(
"Style {} only · Global settings stay unchanged.",
target.index + 1
),
None => {
"Global frame · Applies wherever Style inherits background."
.to_string()
}
},
),
),
)
.child(div().flex().flex_col().gap(px(2.)).p(px(6.)).children(
FRAME_STYLES.into_iter().enumerate().map(
|(index, (value, label, description, icon))| {
let selected = value == style;
div()
.id(("frame-style", index))
.tab_index(0)
.flex()
.items_center()
.gap(px(12.))
.p(px(8.))
.rounded(px(12.))
.cursor_pointer()
.hover(|row| row.bg(theme.gray(3)))
.focus_visible(|row| row.bg(theme.gray(3)))
.child(
div()
.flex()
.items_center()
.justify_center()
.size(px(32.))
.flex_shrink_0()
.rounded(px(10.))
.bg(if selected {
theme.blue_9.into()
} else {
theme.gray(3)
})
.child(svg().path(icon).size(px(16.)).text_color(
if selected {
gpui::white()
} else {
theme.gray(11)
},
)),
)
.child(
div()
.flex()
.flex_col()
.flex_1()
.min_w_0()
.child(
div()
.text_size(px(13.))
.font_weight(FontWeight::MEDIUM)
.text_color(theme.gray(12))
.child(label),
)
.child(
div()
.text_size(px(11.))
.text_color(theme.gray(10))
.child(description),
),
)
.when(selected, |row| {
row.child(
svg()
.path("icons/circle-check.svg")
.size(px(16.))
.flex_shrink_0()
.text_color(theme.blue_9),
)
})
.on_click(cx.listener(move |this, _, window, cx| {
this.change_frame(FrameChange::Style(value), window, cx)
}))
},
),
))
.when(style != FrameStyle::None, |panel| {
panel.child(
div()
.flex()
.flex_col()
.gap(px(12.))
.p(px(12.))
.border_t_1()
.border_color(theme.gray(3))
.child(
div()
.flex()
.items_center()
.justify_between()
.gap(px(12.))
.child(
div()
.text_size(px(12.))
.font_weight(FontWeight::MEDIUM)
.text_color(theme.gray(11))
.child("Theme"),
)
.child(
div()
.flex()
.w(px(160.))
.h(px(32.))
.border_1()
.border_color(theme.gray(3))
.rounded(px(8.))
.p(px(1.))
.children(
[
(FrameTheme::Light, "Light"),
(FrameTheme::Dark, "Dark"),
]
.into_iter()
.map(
|(value, label)| {
div()
.id((
"frame-theme",
usize::from(value == FrameTheme::Dark),
))
.tab_index(0)
.flex()
.flex_1()
.items_center()
.justify_center()
.rounded(px(7.))
.text_size(px(12.))
.text_color(if value == frame_theme {
theme.gray(12)
} else {
theme.gray(11)
})
.when(value == frame_theme, |tab| {
tab.bg(theme.gray(3))
})
.focus_visible(|tab| tab.bg(theme.gray(4)))
.cursor_pointer()
.child(label)
.on_click(cx.listener(
move |this, _, window, cx| {
this.change_frame(
FrameChange::Theme(value),
window,
cx,
)
},
))
},
),
),
),
)
.children(FrameField::for_style(style).and_then(|field| {
let input = &self.frame_controls.fields.as_ref()?[field.index()];
Some(
div()
.flex()
.items_center()
.justify_between()
.gap(px(12.))
.child(
div()
.text_size(px(12.))
.font_weight(FontWeight::MEDIUM)
.text_color(theme.gray(11))
.child(field.label()),
)
.child(
ui::TextInput::plain(
&theme,
("frame-text", field.index()),
input,
)
.width(px(160.))
.height(px(32.))
.radius(px(8.))
.bg(theme.gray(2)),
),
)
})),
)
});
Some(
div()
.absolute()
.top_0()
.left_0()
.size_full()
.child(
div()
.id("frame-backdrop")
.absolute()
.top_0()
.left_0()
.size_full()
.occlude()
.on_mouse_down(
MouseButton::Left,
cx.listener(|this, _, window, cx| {
this.close_frame_controls(window, cx);
cx.stop_propagation();
}),
),
)
.child(
gpui::anchored()
.anchor(gpui::Anchor::TopLeft)
.position(point(bounds.left(), bounds.bottom() + px(8.)))
.snap_to_window_with_margin(px(12.))
.child(panel),
)
.into_any_element(),
)
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::editor_edits::ProjectHistory;
#[test]
fn frame_styles_and_button_labels_match_tauri() {
assert_eq!(
FRAME_STYLES.map(|option| option.1),
["None", "macOS", "Windows", "Browser", "MacBook"]
);
assert_eq!(
button_content(FrameStyle::None),
("Frame", "icons/app-window-mac.svg")
);
for (style, label, _, icon) in FRAME_STYLES.into_iter().skip(1) {
assert_eq!(button_content(style), (label, icon));
}
}
#[test]
fn frame_style_initializes_matching_defaults_and_keeps_existing_settings() {
let mut project = ProjectConfiguration::default();
assert!(apply_frame_change(
&mut project,
FrameChange::Style(FrameStyle::Browser)
));
let frame = project.background.frame.as_ref().unwrap();
assert_eq!(frame.theme, FrameTheme::Dark);
assert_eq!(frame.url, "Cap.so");
assert_eq!(frame.title, "");
assert!(!apply_frame_change(
&mut project,
FrameChange::Style(FrameStyle::Browser)
));
assert!(apply_frame_change(
&mut project,
FrameChange::Text(FrameField::Url, "example.com".into())
));
assert!(apply_frame_change(
&mut project,
FrameChange::Text(FrameField::Title, "Demo".into())
));
assert!(apply_frame_change(
&mut project,
FrameChange::Theme(FrameTheme::Light)
));
for (style, _, _, _) in FRAME_STYLES {
apply_frame_change(&mut project, FrameChange::Style(style));
let frame = project.background.frame.as_ref().unwrap();
assert_eq!(frame.url, "example.com");
assert_eq!(frame.title, "Demo");
assert_eq!(frame.theme, FrameTheme::Light);
}
}
#[test]
fn frame_text_fields_match_tauri_visibility() {
assert!(FrameField::for_style(FrameStyle::Browser) == Some(FrameField::Url));
assert!(FrameField::for_style(FrameStyle::MacOS) == Some(FrameField::Title));
for style in [FrameStyle::None, FrameStyle::Windows, FrameStyle::Macbook] {
assert!(FrameField::for_style(style).is_none());
}
}
/// The pre-PR clone/fallback flow, kept test-only so the benchmark below
/// can measure the clone it removed in the same run as the current one.
/// It shares the current frame mutator, which behaves exactly like the
/// pre-PR one.
fn apply_targeted_frame_change_with_project_clone(
project: &mut ProjectConfiguration,
target: Option<&StyleFrameTarget>,
change: FrameChange,
) -> bool {
let Some(target) = target else {
return apply_frame_change(project, change);
};
if !target.matches(project) {
return false;
}
let mut scoped = project.clone();
let Some(segment) = project
.timeline
.as_ref()
.and_then(|timeline| timeline.style_segments.get(target.index))
else {
return false;
};
scoped.background = segment
.overrides
.background
.clone()
.unwrap_or_else(|| project.background.clone());
if !apply_frame_change(&mut scoped, change) {
return false;
}
let Some(segment) = project
.timeline
.as_mut()
.and_then(|timeline| timeline.style_segments.get_mut(target.index))
else {
return false;
};
segment.overrides.background = Some(scoped.background);
true
}
fn style_frame_project(timeline_segments: usize, with_override: bool) -> ProjectConfiguration {
let mut project = ProjectConfiguration::default();
project.timeline = Some(cap_project::TimelineConfiguration {
segments: (0..timeline_segments)
.map(|index| cap_project::TimelineSegment {
timescale: 1.,
start: index as f64,
end: index as f64 + 1.,
..Default::default()
})
.collect(),
transitions: Vec::new(),
zoom_segments: Vec::new(),
scene_segments: Vec::new(),
mask_segments: Vec::new(),
text_segments: Vec::new(),
caption_segments: Vec::new(),
keyboard_segments: Vec::new(),
audio_segments: Vec::new(),
style_segments: vec![cap_project::StyleSegment {
overrides: cap_project::StyleOverrides {
background: with_override.then(|| BackgroundConfiguration {
frame: Some(FrameConfiguration {
style: FrameStyle::MacOS,
..Default::default()
}),
padding: 77.5,
..Default::default()
}),
..Default::default()
},
..Default::default()
}],
image_segments: Vec::new(),
camera3d_segments: Vec::new(),
});
project
}
fn style_frame_lanes(project: &ProjectConfiguration) -> crate::editor_timeline::TrackLanes {
crate::editor_timeline::TrackLanes::from_project(project, false)
}
fn frame_change_cases() -> [fn() -> FrameChange; 4] {
[
|| FrameChange::Style(FrameStyle::Windows),
|| FrameChange::Theme(FrameTheme::Light),
|| FrameChange::Text(FrameField::Title, "Changed title".into()),
|| FrameChange::Text(FrameField::Url, "https://example.com".into()),
]
}
fn median(samples: &mut Vec<f64>) -> f64 {
assert!(samples.len() > 1, "need a warm-up and a sample");
samples.remove(0);
samples.sort_by(f64::total_cmp);
samples[samples.len() / 2]
}
fn edit_frame_title(
project: &mut ProjectConfiguration,
target: &mut StyleFrameTarget,
i: usize,
j: usize,
clone_project: bool,
) {
let text = format!("Window title {i}-{j}");
let changed = if clone_project {
apply_targeted_frame_change_with_project_clone(
project,
Some(target),
FrameChange::Text(FrameField::Title, text),
)
} else {
apply_targeted_frame_change(
project,
Some(target),
FrameChange::Text(FrameField::Title, text),
)
};
if changed && let Some(next) = StyleFrameTarget::capture(project, target.index) {
*target = next;
}
}
/// One keystroke in a style frame's title field, with the old
/// clone-the-project implementation and the current one measured in the
/// same run, plus the timeline rebuild `project_changed` used to do.
/// `cargo test -p cap-desktop-gpui --bin cap-gpui -- --ignored benchmark_style_frame_edit --nocapture`
#[test]
#[ignore = "manual style frame edit benchmark"]
fn benchmark_style_frame_edit() {
let mut cloned = style_frame_project(2_000, true);
let mut borrowed = cloned.clone();
let mut cloned_target = StyleFrameTarget::capture(&cloned, 0).expect("the style segment");
let mut borrowed_target =
StyleFrameTarget::capture(&borrowed, 0).expect("the style segment");
let mut clone_samples = Vec::new();
for i in 0..32 {
let started = std::time::Instant::now();
for j in 0..10 {
edit_frame_title(&mut cloned, &mut cloned_target, i, j, true);
}
clone_samples.push(started.elapsed().as_secs_f64() * 1_000_000. / 10.);
}
let clone_edit = median(&mut clone_samples);
let mut borrow_samples = Vec::new();
for i in 0..32 {
let started = std::time::Instant::now();
for j in 0..10 {
edit_frame_title(&mut borrowed, &mut borrowed_target, i, j, false);
}
borrow_samples.push(started.elapsed().as_secs_f64() * 1_000_000. / 10.);
}
let borrow_edit = median(&mut borrow_samples);
assert_eq!(
serde_json::to_value(&cloned).unwrap(),
serde_json::to_value(&borrowed).unwrap(),
"the old and new implementations must leave the same project"
);
// The other half of the old per-keystroke path: `project_changed`
// rebuilt this model every time.
let lanes = style_frame_lanes(&borrowed);
let mut rebuild_samples = Vec::new();
for _ in 0..16 {
let started = std::time::Instant::now();
for _ in 0..10 {
drop(std::hint::black_box(
crate::editor_timeline::TimelineModel::build_with_lanes(
&borrowed, false, false, &lanes,
),
));
}
rebuild_samples.push(started.elapsed().as_secs_f64() * 1_000_000. / 10.);
}
let rebuild = median(&mut rebuild_samples);
println!(
"style_frame_edit timeline_segments=2000 clone_edit_us={clone_edit:.3} borrow_edit_us={borrow_edit:.3} timeline_rebuild_us={rebuild:.3}"
);
}
#[test]
fn a_frame_edit_does_not_change_the_timeline_model() {
for with_override in [false, true] {
for targeted in [false, true] {
for change in frame_change_cases() {
let mut project = style_frame_project(64, with_override);
let target = StyleFrameTarget::capture(&project, 0).expect("the style segment");
let lanes = style_frame_lanes(&project);
let before = crate::editor_timeline::TimelineModel::build_with_lanes(
&project, false, false, &lanes,
);
assert!(
apply_targeted_frame_change(
&mut project,
targeted.then_some(&target),
change(),
),
"the frame change should apply \
(override={with_override}, targeted={targeted})"
);
let after = crate::editor_timeline::TimelineModel::build_with_lanes(
&project, false, false, &lanes,
);
assert_eq!(
format!("{before:?}"),
format!("{after:?}"),
"a frame edit must not change anything the timeline model draws \
(override={with_override}, targeted={targeted})"
);
}
}
}
}
#[test]
fn the_targeted_frame_edit_matches_the_clone_the_project_flow() {
for with_override in [false, true] {
for change in frame_change_cases() {
let mut cloned = style_frame_project(8, with_override);
let mut borrowed = cloned.clone();
let target = StyleFrameTarget::capture(&cloned, 0).expect("the style segment");
assert_eq!(
apply_targeted_frame_change_with_project_clone(
&mut cloned,
Some(&target),
change(),
),
apply_targeted_frame_change(&mut borrowed, Some(&target), change()),
"the old and new implementations must agree (override={with_override})"
);
assert_eq!(
serde_json::to_value(&cloned).unwrap(),
serde_json::to_value(&borrowed).unwrap(),
"the old and new implementations must leave the same project \
(override={with_override})"
);
}
}
// A missing target takes the global-background path in both.
let mut cloned = style_frame_project(8, false);
let mut borrowed = cloned.clone();
assert_eq!(
apply_targeted_frame_change_with_project_clone(
&mut cloned,
None,
FrameChange::Style(FrameStyle::Windows),
),
apply_targeted_frame_change(
&mut borrowed,
None,
FrameChange::Style(FrameStyle::Windows),
)
);
assert_eq!(
serde_json::to_value(&cloned).unwrap(),
serde_json::to_value(&borrowed).unwrap()
);
// A stale target is a no-op in both.
let mut cloned = style_frame_project(8, false);
let mut borrowed = cloned.clone();
let target = StyleFrameTarget::capture(&cloned, 0).expect("the style segment");
cloned.timeline.as_mut().unwrap().style_segments[0].name = "Moved".into();
borrowed.timeline.as_mut().unwrap().style_segments[0].name = "Moved".into();
assert!(!apply_targeted_frame_change_with_project_clone(
&mut cloned,
Some(&target),
FrameChange::Style(FrameStyle::Windows),
));
assert!(!apply_targeted_frame_change(
&mut borrowed,
Some(&target),
FrameChange::Style(FrameStyle::Windows),
));
assert_eq!(
serde_json::to_value(&cloned).unwrap(),
serde_json::to_value(&borrowed).unwrap()
);
}
#[test]
fn frame_changes_round_trip_and_undo_without_changing_the_background() {
let mut project = ProjectConfiguration::default();
let source = serde_json::to_value(&project.background.source).unwrap();
let mut history = ProjectHistory::new(project.clone());
for (style, _, _, _) in FRAME_STYLES {
apply_frame_change(&mut project, FrameChange::Style(style));
history.record(&project);
let saved = serde_json::to_vec(&project).unwrap();
let loaded: ProjectConfiguration = serde_json::from_slice(&saved).unwrap();
assert_eq!(loaded.background.frame, project.background.frame);
assert_eq!(
serde_json::to_value(&loaded.background.source).unwrap(),
source
);
}
assert_eq!(
history
.undo()
.unwrap()
.background
.frame
.as_ref()
.unwrap()
.style,
FrameStyle::Browser
);
assert_eq!(
history
.redo()
.unwrap()
.background
.frame
.as_ref()
.unwrap()
.style,
FrameStyle::Macbook
);
}
}
#[cfg(test)]
mod style_image_tests {
use super::*;
#[test]
fn style_image_frame_opt_in_preserves_globals_and_rejects_stale_target() {
let mut project: ProjectConfiguration = serde_json::from_value(serde_json::json!({"timeline":{"zoomSegments":[],"segments":[],"styleSegments":[{"start":1,"end":5,"name":"A"},{"start":7,"end":9,"name":"B"}]}})).unwrap();
let base = project.background.clone();
let target = StyleFrameTarget::capture(&project, 0).unwrap();
assert!(apply_targeted_frame_change(
&mut project,
Some(&target),
FrameChange::Style(FrameStyle::Browser)
));
assert_eq!(
serde_json::to_value(&project.background).unwrap(),
serde_json::to_value(&base).unwrap()
);
let target = StyleFrameTarget::capture(&project, 0).unwrap();
assert!(apply_targeted_frame_change(
&mut project,
Some(&target),
FrameChange::Text(FrameField::Url, "example.com".into())
));
let target = StyleFrameTarget::capture(&project, 0).unwrap();
project.timeline.as_mut().unwrap().style_segments.swap(0, 1);
assert!(!apply_targeted_frame_change(
&mut project,
Some(&target),
FrameChange::Style(FrameStyle::Windows)
));
assert!(
project.timeline.as_ref().unwrap().style_segments[0]
.overrides
.background
.is_none()
);
assert_eq!(
serde_json::to_value(&project.background).unwrap(),
serde_json::to_value(&base).unwrap()
);
let frame = project.timeline.as_ref().unwrap().style_segments[1]
.overrides
.background
.as_ref()
.unwrap()
.frame
.as_ref()
.unwrap();
assert_eq!(frame.style, FrameStyle::Browser);
assert_eq!(frame.url, "example.com");
}
}