414 lines
16 KiB
Rust
414 lines
16 KiB
Rust
//! Session-only, explicitly enabled edits to the device's shared input settings.
|
|
use super::*;
|
|
use midra_layout::{
|
|
device::Snapshot,
|
|
device_send::{Change, Plan},
|
|
};
|
|
use serde_json::{Value, json};
|
|
use std::collections::{BTreeMap, BTreeSet};
|
|
|
|
#[derive(Default)]
|
|
pub(super) struct InputEdits {
|
|
pub enabled: bool,
|
|
// Only fields actually edited are staged; opening the tab never stages defaults.
|
|
values: BTreeMap<String, Value>,
|
|
}
|
|
|
|
fn input_path(snapshot: &Snapshot, screen: &str, bank: &str, layer: &str) -> Option<String> {
|
|
let input = snapshot.raw.pointer(&format!("/device/screenList/items/{screen}/presetList/items/{bank}/liveLayerList/items/{layer}/source/pp/input"))?.as_str()?;
|
|
let base = format!("/device/inputList/items/{input}");
|
|
let plug = snapshot
|
|
.raw
|
|
.pointer(&format!("{base}/status/pp/plug"))?
|
|
.as_str()?;
|
|
Some(format!("{base}/plugList/items/{plug}/settings"))
|
|
}
|
|
|
|
fn setting_label(value: &str) -> String {
|
|
match value {
|
|
"NATIVE" => "Native".into(),
|
|
"SIGNAL" => "Signal".into(),
|
|
"CUSTOM" => "Custom".into(),
|
|
"LAYER_SETTING" => "Layer setting".into(),
|
|
"CENTERED" => "Centered".into(),
|
|
"FULLSCREEN" => "Full screen".into(),
|
|
"CROPPED" => "Cropped".into(),
|
|
"NONE" => "None".into(),
|
|
"LETTERBOX_1_78" => "Letterbox 1.78:1".into(),
|
|
"LETTERBOX_1_85" => "Letterbox 1.85:1".into(),
|
|
"LETTERBOX_2_35" => "Letterbox 2.35:1".into(),
|
|
"PILLARBOX_1_33" => "Pillarbox 1.33:1".into(),
|
|
_ => value.replace('_', ":"),
|
|
}
|
|
}
|
|
|
|
impl InputEdits {
|
|
pub fn clear(&mut self) {
|
|
*self = Self::default();
|
|
}
|
|
|
|
pub fn show(
|
|
&mut self,
|
|
ui: &mut egui::Ui,
|
|
snapshot: Option<&Snapshot>,
|
|
link: Option<&midra_layout::MidraLink>,
|
|
) {
|
|
ui.label(
|
|
"Advanced — use only when you need to correct an input and understand the effect.",
|
|
);
|
|
ui.label("These device controls map one-for-one to WebRCS Advanced Input settings. Content ratio / Transform to change the input's aspect before layer framing. Usually leave them set on the Midra.");
|
|
ui.label("Input crop removes source edges before dynamic layer crop / zoom. It does not resize the layer's bounding box. This processing is a Midra feature, not an editor-only effect.");
|
|
if ui
|
|
.checkbox(
|
|
&mut self.enabled,
|
|
"Edit advanced input settings and include my edits when sending",
|
|
)
|
|
.changed()
|
|
&& !self.enabled
|
|
{
|
|
self.values.clear();
|
|
}
|
|
ui.small("Off by default. Only edited device fields are sent, and only with layers using that input. Inputs are shared: edits can affect other layers and Program too. Uncheck to discard staged edits. This opt-in lasts for this session only.");
|
|
let Some((snapshot, base)) = snapshot.and_then(|snapshot| {
|
|
let link = link?;
|
|
let screen = snapshot.screens.iter().find(|s| s.id == link.screen)?;
|
|
input_path(snapshot, &link.screen, &screen.preview_bank, &link.layer)
|
|
.map(|base| (snapshot, base))
|
|
}) else {
|
|
ui.small("Connect and map this layer to a Midra input source to inspect its advanced settings. No device input edits are staged offline.");
|
|
return;
|
|
};
|
|
ui.small(format!(
|
|
"Shared input: {} · plug {} (from linked Preview layer)",
|
|
base.split('/').nth(4).unwrap_or("?"),
|
|
base.split('/').nth(7).unwrap_or("?")
|
|
));
|
|
ui.add_enabled_ui(self.enabled, |ui| {
|
|
for (suffix, label, options) in [
|
|
(
|
|
"aspect/pp/signal",
|
|
"Content ratio",
|
|
&[
|
|
"NATIVE", "5_4", "4_3", "16_10", "15_9", "16_9", "21_9", "256_135", "64_27",
|
|
][..],
|
|
),
|
|
(
|
|
"aspect/pp/transformTo",
|
|
"Transform to",
|
|
&[
|
|
"SIGNAL", "5_4", "4_3", "16_10", "15_9", "16_9", "21_9", "CUSTOM",
|
|
][..],
|
|
),
|
|
(
|
|
"aspect/pp/layerFill",
|
|
"Layer fill option",
|
|
&["LAYER_SETTING", "1_1", "CENTERED", "FULLSCREEN", "CROPPED"][..],
|
|
),
|
|
(
|
|
"cropping/control/pp/predefined",
|
|
"Input crop preset",
|
|
&[
|
|
"NONE",
|
|
"LETTERBOX_1_78",
|
|
"LETTERBOX_1_85",
|
|
"LETTERBOX_2_35",
|
|
"PILLARBOX_1_33",
|
|
][..],
|
|
),
|
|
] {
|
|
let path = format!("{base}/{suffix}");
|
|
let Some(original) = snapshot.raw.pointer(&path) else {
|
|
continue;
|
|
};
|
|
let mut value = self
|
|
.values
|
|
.get(&path)
|
|
.unwrap_or(original)
|
|
.as_str()
|
|
.unwrap_or_default()
|
|
.to_owned();
|
|
let before = value.clone();
|
|
ui.horizontal(|ui| {
|
|
ui.label(label);
|
|
egui::ComboBox::from_id_salt(&path)
|
|
.selected_text(setting_label(&value))
|
|
.show_ui(ui, |ui| {
|
|
for option in options {
|
|
ui.selectable_value(
|
|
&mut value,
|
|
(*option).into(),
|
|
setting_label(option),
|
|
);
|
|
}
|
|
});
|
|
});
|
|
if value != before {
|
|
self.stage(path, json!(value), original);
|
|
}
|
|
}
|
|
for (suffix, label, min, max, scale) in [
|
|
(
|
|
"aspect/pp/customRatio",
|
|
"Custom aspect ratio ",
|
|
250.,
|
|
10000.,
|
|
0.001,
|
|
),
|
|
(
|
|
"cropping/control/pp/left",
|
|
"Input crop left ",
|
|
0.,
|
|
8191.,
|
|
1.,
|
|
),
|
|
(
|
|
"cropping/control/pp/right",
|
|
"Input crop right ",
|
|
0.,
|
|
8191.,
|
|
1.,
|
|
),
|
|
("cropping/control/pp/top", "Input crop top ", 0., 8191., 1.),
|
|
(
|
|
"cropping/control/pp/bottom",
|
|
"Input crop bottom ",
|
|
0.,
|
|
8191.,
|
|
1.,
|
|
),
|
|
] {
|
|
let path = format!("{base}/{suffix}");
|
|
let Some(original) = snapshot.raw.pointer(&path) else {
|
|
continue;
|
|
};
|
|
let mut value = self
|
|
.values
|
|
.get(&path)
|
|
.unwrap_or(original)
|
|
.as_f64()
|
|
.unwrap_or_default()
|
|
* scale;
|
|
if ui
|
|
.add(
|
|
egui::DragValue::new(&mut value)
|
|
.range(min * scale..=max * scale)
|
|
.speed(scale)
|
|
.prefix(label)
|
|
.max_decimals(if scale == 1. { 0 } else { 3 }),
|
|
)
|
|
.changed()
|
|
{
|
|
self.stage(path, json!((value / scale).round() as i64), original);
|
|
}
|
|
}
|
|
});
|
|
ui.small("Edits wait for Send; opening this tab or enabling the checkbox sends nothing. Refresh/load after sending to inspect the device's resulting content dimensions.");
|
|
}
|
|
fn stage(&mut self, path: String, value: Value, original: &Value) {
|
|
if &value == original {
|
|
self.values.remove(&path);
|
|
} else {
|
|
self.values.insert(path, value);
|
|
}
|
|
}
|
|
pub fn extend_plan(
|
|
&self,
|
|
snapshot: &Snapshot,
|
|
mappings: &[(usize, String)],
|
|
plan: &mut Plan,
|
|
) -> Result<(), String> {
|
|
if !self.enabled {
|
|
return Ok(());
|
|
}
|
|
let inputs: BTreeSet<_> = mappings
|
|
.iter()
|
|
.filter_map(|(_, layer)| input_path(snapshot, &plan.screen, &plan.bank, layer))
|
|
.collect();
|
|
let mut changes = Vec::new();
|
|
for (path, after) in &self.values {
|
|
if !inputs
|
|
.iter()
|
|
.any(|base| path.starts_with(&format!("{base}/")))
|
|
{
|
|
continue;
|
|
}
|
|
let before = snapshot
|
|
.raw
|
|
.pointer(path)
|
|
.ok_or("Refresh the device: a staged input setting is unavailable.")?;
|
|
if before != after {
|
|
changes.push(Change {
|
|
path: path
|
|
.trim_start_matches('/')
|
|
.split('/')
|
|
.map(str::to_owned)
|
|
.collect(),
|
|
before: before.clone(),
|
|
after: after.clone(),
|
|
});
|
|
}
|
|
}
|
|
changes.append(&mut plan.changes);
|
|
plan.changes = changes;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use midra_layout::device_send::Target;
|
|
|
|
fn fixture() -> Snapshot {
|
|
Snapshot {
|
|
identity: "Test".into(),
|
|
screens: vec![],
|
|
raw: json!({"device": {"inputList": {"items": {"INPUT_4": {"status": {"pp": {"plug": "2"}}, "plugList": {"items": {"2": {"settings": {"aspect": {"pp": {"signal": "NATIVE", "transformTo": "SIGNAL", "customRatio": 1333, "layerFill": "LAYER_SETTING"}}, "cropping": {"control": {"pp": {"left": 0, "right": 0, "top": 0, "bottom": 0, "predefined": "NONE", "xUpdate": true}}}}}}}}}}, "screenList": {"items": {"1": {"presetList": {"items": {"UP": {"liveLayerList": {"items": {"1": {"source": {"pp": {"input": "INPUT_4"}}}, "2": {"source": {"pp": {"input": "INPUT_NONE"}}}}}}, "DOWN": {"liveLayerList": {"items": {"1": {"source": {"pp": {"input": "INPUT_NONE"}}}}}}}}}}}}}),
|
|
}
|
|
}
|
|
fn empty_plan() -> Plan {
|
|
Plan {
|
|
screen: "1".into(),
|
|
bank: "UP".into(),
|
|
target: Target::Preview,
|
|
changes: vec![],
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn connected_source_controls_open_read_only_and_unchecking_discards_edits() {
|
|
let mut snapshot = fixture();
|
|
snapshot.screens.push(midra_layout::device::Screen {
|
|
id: "1".into(),
|
|
resolution: [1920, 1080],
|
|
preview_bank: "UP".into(),
|
|
layers: vec![],
|
|
});
|
|
let link = midra_layout::MidraLink {
|
|
screen: "1".into(),
|
|
layer: "1".into(),
|
|
};
|
|
let ctx = egui::Context::default();
|
|
let mut edits = InputEdits::default();
|
|
let mut draw = |edits: &mut InputEdits, events| {
|
|
ctx.run(
|
|
egui::RawInput {
|
|
screen_rect: Some(egui::Rect::from_min_size(
|
|
egui::Pos2::ZERO,
|
|
egui::vec2(900., 1000.),
|
|
)),
|
|
events,
|
|
..Default::default()
|
|
},
|
|
|ctx| {
|
|
egui::CentralPanel::default()
|
|
.show(ctx, |ui| edits.show(ui, Some(&snapshot), Some(&link)));
|
|
},
|
|
)
|
|
};
|
|
draw(&mut edits, vec![]);
|
|
let output = draw(&mut edits, vec![]);
|
|
assert!(!edits.enabled);
|
|
assert!(edits.values.is_empty());
|
|
assert!(output.shapes.iter().any(|shape| matches!(&shape.shape, egui::Shape::Text(t) if t.galley.text() == "Content ratio")));
|
|
let pos = output
|
|
.shapes
|
|
.iter()
|
|
.find_map(|shape| match &shape.shape {
|
|
egui::Shape::Text(t)
|
|
if t.galley.text()
|
|
== "Edit advanced input settings and include my edits when sending" =>
|
|
{
|
|
Some(t.pos + egui::vec2(10., 5.))
|
|
}
|
|
_ => None,
|
|
})
|
|
.unwrap();
|
|
let click = |edits: &mut InputEdits,
|
|
draw: &mut dyn FnMut(
|
|
&mut InputEdits,
|
|
Vec<egui::Event>,
|
|
) -> egui::FullOutput| {
|
|
draw(
|
|
edits,
|
|
vec![
|
|
egui::Event::PointerMoved(pos),
|
|
super::super::tests::mouse(pos, true),
|
|
],
|
|
);
|
|
draw(edits, vec![super::super::tests::mouse(pos, false)]);
|
|
};
|
|
click(&mut edits, &mut draw);
|
|
assert!(edits.enabled);
|
|
assert!(edits.values.is_empty());
|
|
edits.stage("test".into(), json!(40), &json!(0));
|
|
click(&mut edits, &mut draw);
|
|
assert!(!edits.enabled);
|
|
assert!(edits.values.is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn default_enable_only_and_unrelated_layers_never_write_inputs() {
|
|
let snapshot = fixture();
|
|
let mappings = [(1, "1".into())];
|
|
let mut edits = InputEdits::default();
|
|
let mut plan = empty_plan();
|
|
edits.extend_plan(&snapshot, &mappings, &mut plan).unwrap();
|
|
assert!(plan.changes.is_empty());
|
|
edits.enabled = true;
|
|
edits.extend_plan(&snapshot, &mappings, &mut plan).unwrap();
|
|
assert!(plan.changes.is_empty());
|
|
let path = format!(
|
|
"{}/cropping/control/pp/left",
|
|
input_path(&snapshot, "1", "UP", "1").unwrap()
|
|
);
|
|
edits.stage(path.clone(), json!(40), &json!(0));
|
|
edits
|
|
.extend_plan(&snapshot, &[(2, "2".into())], &mut plan)
|
|
.unwrap();
|
|
assert!(plan.changes.is_empty());
|
|
edits.extend_plan(&snapshot, &mappings, &mut plan).unwrap();
|
|
assert_eq!(plan.changes.len(), 1);
|
|
assert_eq!(plan.changes[0].path.join("/"), path.trim_start_matches('/'));
|
|
assert_eq!(plan.changes[0].after, json!(40));
|
|
// Program has a different routed source and must not receive Preview input edits.
|
|
let mut program = empty_plan();
|
|
program.bank = "DOWN".into();
|
|
program.target = Target::Program;
|
|
edits
|
|
.extend_plan(&snapshot, &mappings, &mut program)
|
|
.unwrap();
|
|
assert!(program.changes.is_empty());
|
|
edits.enabled = false;
|
|
let mut disabled = empty_plan();
|
|
edits
|
|
.extend_plan(&snapshot, &mappings, &mut disabled)
|
|
.unwrap();
|
|
assert!(disabled.changes.is_empty());
|
|
edits.clear();
|
|
assert!(edits.values.is_empty());
|
|
assert!(!edits.enabled);
|
|
}
|
|
|
|
#[test]
|
|
fn reverted_values_are_not_staged_and_duplicate_routes_are_written_once() {
|
|
let snapshot = fixture();
|
|
let path = format!(
|
|
"{}/aspect/pp/transformTo",
|
|
input_path(&snapshot, "1", "UP", "1").unwrap()
|
|
);
|
|
let mut edits = InputEdits {
|
|
enabled: true,
|
|
..Default::default()
|
|
};
|
|
edits.stage(path.clone(), json!("16_9"), &json!("SIGNAL"));
|
|
let mut plan = empty_plan();
|
|
edits
|
|
.extend_plan(&snapshot, &[(1, "1".into()), (2, "1".into())], &mut plan)
|
|
.unwrap();
|
|
assert_eq!(plan.changes.len(), 1);
|
|
edits.stage(path, json!("SIGNAL"), &json!("SIGNAL"));
|
|
assert!(edits.values.is_empty());
|
|
}
|
|
}
|