912 lines
32 KiB
Rust
912 lines
32 KiB
Rust
use std::str::FromStr;
|
|
|
|
use toml_edit::{Array, ArrayOfTables, DocumentMut, InlineTable, Item, Table, Value, value};
|
|
|
|
use crate::{
|
|
Action, ConfigError, FaderDensity, MessageKind, MixerOrientation, Profile, SelectorField,
|
|
SeparatorDecoration, SeparatorSize, StatusDisplayMode, TargetKind, UiTheme,
|
|
};
|
|
|
|
/// Match expression used when creating an application selector.
|
|
#[derive(Clone, Debug, Eq, PartialEq)]
|
|
pub enum SelectorPattern {
|
|
Exact(String),
|
|
Regex(String),
|
|
}
|
|
|
|
/// Editable selector input for a virtual application.
|
|
#[derive(Clone, Debug, Eq, PartialEq)]
|
|
pub struct SelectorDraft {
|
|
pub field: SelectorField,
|
|
pub pattern: SelectorPattern,
|
|
}
|
|
|
|
/// A comment-preserving profile edit that is revalidated before use.
|
|
#[derive(Debug)]
|
|
pub struct ProfileDocument {
|
|
document: DocumentMut,
|
|
}
|
|
|
|
impl ProfileDocument {
|
|
/// Builds a safe first-run profile with a default-output fader and no MIDI surfaces.
|
|
pub fn empty(id: &str) -> Result<Self, ConfigError> {
|
|
Self::parse(&format!(
|
|
r#"schema_version = 1
|
|
id = {id:?}
|
|
startup = "adopt"
|
|
new_stream = "adopt"
|
|
|
|
[audio]
|
|
adapter = "auto"
|
|
preference = ["pulse", "pipewire"]
|
|
max_gain = 1.0
|
|
|
|
[[faders]]
|
|
id = "master-fader"
|
|
target = {{ kind = "output", id = "default" }}
|
|
pickup = true
|
|
pickup_tolerance = 0.02
|
|
"#
|
|
))
|
|
}
|
|
|
|
/// Builds a safe replacement for this profile while retaining runtime timing.
|
|
///
|
|
/// Runtime timing cannot be changed while the native worker is running, so an
|
|
/// emergency reset clears user routing and presentation data but carries that
|
|
/// one process-level setting into the replacement document.
|
|
pub fn safe_defaults(&self) -> Result<Self, ConfigError> {
|
|
let profile = self.preview()?;
|
|
let mut replacement = Self::empty(profile.id().as_str())?;
|
|
if let Some(runtime) = self.document.get("runtime") {
|
|
replacement.document["runtime"] = runtime.clone();
|
|
}
|
|
replacement.preview()?;
|
|
Ok(replacement)
|
|
}
|
|
|
|
/// Parses both the editable TOML representation and semantic profile.
|
|
pub fn parse(input: &str) -> Result<Self, ConfigError> {
|
|
Profile::parse(input)?;
|
|
let document = DocumentMut::from_str(input)?;
|
|
Ok(Self { document })
|
|
}
|
|
|
|
/// Changes the direction used to arrange faders in the mixer.
|
|
pub fn set_mixer_orientation(
|
|
&mut self,
|
|
orientation: MixerOrientation,
|
|
) -> Result<(), ConfigError> {
|
|
self.transaction(|document| {
|
|
if document.get("ui").is_none() {
|
|
document["ui"] = Item::Table(Table::new());
|
|
}
|
|
let ui = document
|
|
.get_mut("ui")
|
|
.and_then(Item::as_table_mut)
|
|
.ok_or_else(|| ConfigError::validation("ui", "must be a table"))?;
|
|
ui["mixer_orientation"] = value(match orientation {
|
|
MixerOrientation::Vertical => "vertical",
|
|
MixerOrientation::Horizontal => "horizontal",
|
|
});
|
|
Ok(())
|
|
})
|
|
}
|
|
|
|
/// Changes how pickup state is represented on mixer faders.
|
|
pub fn set_status_display(&mut self, mode: StatusDisplayMode) -> Result<(), ConfigError> {
|
|
self.transaction(|document| {
|
|
if document.get("ui").is_none() {
|
|
document["ui"] = Item::Table(Table::new());
|
|
}
|
|
let ui = document
|
|
.get_mut("ui")
|
|
.and_then(Item::as_table_mut)
|
|
.ok_or_else(|| ConfigError::validation("ui", "must be a table"))?;
|
|
ui["status_display"] = value(match mode {
|
|
StatusDisplayMode::Detailed => "detailed",
|
|
StatusDisplayMode::Compact => "compact",
|
|
StatusDisplayMode::Symbol => "symbol",
|
|
StatusDisplayMode::Color => "color",
|
|
StatusDisplayMode::Hidden => "hidden",
|
|
});
|
|
Ok(())
|
|
})
|
|
}
|
|
|
|
/// Selects the configured surface inherited by new MIDI assignments.
|
|
pub fn set_default_controller(&mut self, surface: Option<&str>) -> Result<(), ConfigError> {
|
|
self.transaction(|document| {
|
|
if document.get("ui").is_none() {
|
|
document["ui"] = Item::Table(Table::new());
|
|
}
|
|
let ui = document
|
|
.get_mut("ui")
|
|
.and_then(Item::as_table_mut)
|
|
.ok_or_else(|| ConfigError::validation("ui", "must be a table"))?;
|
|
if let Some(surface) = surface {
|
|
ui["default_controller"] = value(surface);
|
|
} else {
|
|
ui.remove("default_controller");
|
|
}
|
|
Ok(())
|
|
})
|
|
}
|
|
|
|
/// Changes the saved terminal palette.
|
|
pub fn set_theme(&mut self, theme: UiTheme) -> Result<(), ConfigError> {
|
|
self.transaction(|document| {
|
|
if document.get("ui").is_none() {
|
|
document["ui"] = Item::Table(Table::new());
|
|
}
|
|
let ui = document
|
|
.get_mut("ui")
|
|
.and_then(Item::as_table_mut)
|
|
.ok_or_else(|| ConfigError::validation("ui", "must be a table"))?;
|
|
ui["theme"] = value(match theme {
|
|
UiTheme::Default => "default",
|
|
UiTheme::Dracula => "dracula",
|
|
UiTheme::Nord => "nord",
|
|
UiTheme::GruvboxDark => "gruvbox-dark",
|
|
UiTheme::CatppuccinMocha => "catppuccin-mocha",
|
|
UiTheme::SolarizedDark => "solarized-dark",
|
|
});
|
|
Ok(())
|
|
})
|
|
}
|
|
|
|
/// Adds a discovered MIDI input as a durable control surface.
|
|
#[allow(clippy::too_many_arguments)]
|
|
pub fn add_surface(
|
|
&mut self,
|
|
id: &str,
|
|
label: &str,
|
|
input_port: &str,
|
|
output_port: Option<&str>,
|
|
usb_vendor_id: Option<&str>,
|
|
usb_product_id: Option<&str>,
|
|
usb_serial: Option<&str>,
|
|
usb_path: Option<&str>,
|
|
manual_backend_id: Option<&str>,
|
|
) -> Result<(), ConfigError> {
|
|
self.transaction(|document| {
|
|
if document.get("surfaces").is_none() {
|
|
document["surfaces"] = Item::ArrayOfTables(ArrayOfTables::new());
|
|
}
|
|
let surfaces = document
|
|
.get_mut("surfaces")
|
|
.and_then(Item::as_array_of_tables_mut)
|
|
.ok_or_else(|| ConfigError::validation("surfaces", "must be an array of tables"))?;
|
|
let mut table = Table::new();
|
|
table["id"] = value(id);
|
|
table["label"] = value(label);
|
|
table["input_port"] = value(input_port);
|
|
if let Some(output_port) = output_port {
|
|
table["output_port"] = value(output_port);
|
|
}
|
|
if let Some(vendor) = usb_vendor_id {
|
|
table["usb_vendor_id"] = value(vendor);
|
|
}
|
|
if let Some(product) = usb_product_id {
|
|
table["usb_product_id"] = value(product);
|
|
}
|
|
if let Some(serial) = usb_serial {
|
|
table["usb_serial"] = value(serial);
|
|
}
|
|
if let Some(path) = usb_path {
|
|
table["usb_path"] = value(path);
|
|
}
|
|
if let Some(backend_id) = manual_backend_id {
|
|
table["manual_backend_id"] = value(backend_id);
|
|
}
|
|
table["identity_policy"] = value(if manual_backend_id.is_some() {
|
|
"manual"
|
|
} else {
|
|
"require_unique"
|
|
});
|
|
table["motorized"] = value(false);
|
|
surfaces.push(table);
|
|
Ok(())
|
|
})
|
|
}
|
|
|
|
/// Changes one application's display label without rebuilding its table.
|
|
pub fn set_application_label(
|
|
&mut self,
|
|
application_id: &str,
|
|
label: &str,
|
|
) -> Result<(), ConfigError> {
|
|
self.transaction(|document| {
|
|
let applications = document
|
|
.get_mut("applications")
|
|
.and_then(Item::as_array_of_tables_mut)
|
|
.ok_or_else(|| {
|
|
ConfigError::validation("applications", "missing application array")
|
|
})?;
|
|
let Some(application) = applications.iter_mut().find(|table| {
|
|
table
|
|
.get("id")
|
|
.and_then(Item::as_str)
|
|
.is_some_and(|id| id == application_id)
|
|
}) else {
|
|
return Err(ConfigError::validation(
|
|
"applications",
|
|
format!("unknown application {application_id:?}"),
|
|
));
|
|
};
|
|
let existing = application
|
|
.get_mut("label")
|
|
.and_then(Item::as_value_mut)
|
|
.ok_or_else(|| {
|
|
ConfigError::validation("applications.label", "missing string label")
|
|
})?;
|
|
let decor = existing.decor().clone();
|
|
let mut replacement = Value::from(label);
|
|
*replacement.decor_mut() = decor;
|
|
*existing = replacement;
|
|
Ok(())
|
|
})
|
|
}
|
|
|
|
/// Adds a virtual application and validates the whole resulting profile.
|
|
pub fn add_application(
|
|
&mut self,
|
|
id: &str,
|
|
label: &str,
|
|
selectors: &[SelectorDraft],
|
|
) -> Result<(), ConfigError> {
|
|
self.transaction(|document| {
|
|
let applications = document
|
|
.get_mut("applications")
|
|
.and_then(Item::as_array_of_tables_mut)
|
|
.ok_or_else(|| {
|
|
ConfigError::validation("applications", "missing application array")
|
|
})?;
|
|
let mut table = Table::new();
|
|
table["id"] = value(id);
|
|
table["label"] = value(label);
|
|
table["selectors"] = value(selector_array(selectors));
|
|
applications.push(table);
|
|
Ok(())
|
|
})
|
|
}
|
|
|
|
/// Replaces an application's editable fields while retaining table comments.
|
|
pub fn set_application(
|
|
&mut self,
|
|
id: &str,
|
|
label: &str,
|
|
selectors: &[SelectorDraft],
|
|
) -> Result<(), ConfigError> {
|
|
self.transaction(|document| {
|
|
let table = find_table_mut(document, "applications", id)?;
|
|
table["label"] = value(label);
|
|
table["selectors"] = value(selector_array(selectors));
|
|
Ok(())
|
|
})
|
|
}
|
|
|
|
/// Replaces one capture selector while retaining every other selector.
|
|
pub fn set_application_selector(
|
|
&mut self,
|
|
id: &str,
|
|
index: usize,
|
|
selector: &SelectorDraft,
|
|
) -> Result<(), ConfigError> {
|
|
self.transaction(|document| {
|
|
let table = find_table_mut(document, "applications", id)?;
|
|
let selectors = table
|
|
.get_mut("selectors")
|
|
.and_then(Item::as_value_mut)
|
|
.and_then(Value::as_array_mut)
|
|
.ok_or_else(|| {
|
|
ConfigError::validation("applications.selectors", "missing selector array")
|
|
})?;
|
|
let value = selectors.get_mut(index).ok_or_else(|| {
|
|
ConfigError::validation(
|
|
"applications.selectors",
|
|
format!("unknown selector index {index}"),
|
|
)
|
|
})?;
|
|
let decor = value.decor().clone();
|
|
let mut replacement = Value::InlineTable(selector_table(selector));
|
|
*replacement.decor_mut() = decor;
|
|
*value = replacement;
|
|
Ok(())
|
|
})
|
|
}
|
|
|
|
/// Removes an application only when no remaining object references it.
|
|
pub fn remove_application(&mut self, id: &str) -> Result<(), ConfigError> {
|
|
self.transaction(|document| {
|
|
let applications = document
|
|
.get_mut("applications")
|
|
.and_then(Item::as_array_of_tables_mut)
|
|
.ok_or_else(|| {
|
|
ConfigError::validation("applications", "missing application array")
|
|
})?;
|
|
let index = applications
|
|
.iter()
|
|
.position(|table| table.get("id").and_then(Item::as_str) == Some(id))
|
|
.ok_or_else(|| {
|
|
ConfigError::validation("applications", format!("unknown application {id:?}"))
|
|
})?;
|
|
applications.remove(index);
|
|
Ok(())
|
|
})
|
|
}
|
|
|
|
/// Adds an absolute group and validates all member references.
|
|
pub fn add_group(
|
|
&mut self,
|
|
id: &str,
|
|
label: &str,
|
|
members: &[&str],
|
|
) -> Result<(), ConfigError> {
|
|
self.transaction(|document| {
|
|
let groups = document
|
|
.get_mut("groups")
|
|
.and_then(Item::as_array_of_tables_mut)
|
|
.ok_or_else(|| ConfigError::validation("groups", "missing group array"))?;
|
|
let mut table = Table::new();
|
|
table["id"] = value(id);
|
|
table["label"] = value(label);
|
|
table["members"] = value(string_array(members));
|
|
table["volume_mode"] = value("absolute");
|
|
groups.push(table);
|
|
Ok(())
|
|
})
|
|
}
|
|
|
|
/// Replaces a group's label and member set without changing its mode.
|
|
pub fn set_group(
|
|
&mut self,
|
|
id: &str,
|
|
label: &str,
|
|
members: &[&str],
|
|
) -> Result<(), ConfigError> {
|
|
self.transaction(|document| {
|
|
let table = find_table_mut(document, "groups", id)?;
|
|
table["label"] = value(label);
|
|
table["members"] = value(string_array(members));
|
|
Ok(())
|
|
})
|
|
}
|
|
|
|
/// Removes an unreferenced group.
|
|
pub fn remove_group(&mut self, id: &str) -> Result<(), ConfigError> {
|
|
self.remove_table("groups", id)
|
|
}
|
|
|
|
/// Adds a logical fader and validates its target.
|
|
pub fn add_fader(
|
|
&mut self,
|
|
id: &str,
|
|
target_kind: TargetKind,
|
|
target_id: &str,
|
|
pickup: bool,
|
|
pickup_tolerance: f64,
|
|
) -> Result<(), ConfigError> {
|
|
self.transaction(|document| {
|
|
let faders = document
|
|
.get_mut("faders")
|
|
.and_then(Item::as_array_of_tables_mut)
|
|
.ok_or_else(|| ConfigError::validation("faders", "missing fader array"))?;
|
|
let mut table = Table::new();
|
|
table["id"] = value(id);
|
|
table["target"] = value(target_table(target_kind, target_id));
|
|
table["pickup"] = value(pickup);
|
|
table["pickup_tolerance"] = value(pickup_tolerance);
|
|
faders.push(table);
|
|
Ok(())
|
|
})
|
|
}
|
|
|
|
/// Replaces a fader's target and pickup policy.
|
|
pub fn set_fader(
|
|
&mut self,
|
|
id: &str,
|
|
target_kind: TargetKind,
|
|
target_id: &str,
|
|
pickup: bool,
|
|
pickup_tolerance: f64,
|
|
) -> Result<(), ConfigError> {
|
|
self.transaction(|document| {
|
|
let table = find_table_mut(document, "faders", id)?;
|
|
table["target"] = value(target_table(target_kind, target_id));
|
|
table["pickup"] = value(pickup);
|
|
table["pickup_tolerance"] = value(pickup_tolerance);
|
|
Ok(())
|
|
})
|
|
}
|
|
|
|
/// Removes a fader only when no binding references it.
|
|
pub fn remove_fader(&mut self, id: &str) -> Result<(), ConfigError> {
|
|
self.remove_table("faders", id)
|
|
}
|
|
|
|
/// Adds a presentation-only separator at the requested layout position.
|
|
pub fn add_separator(
|
|
&mut self,
|
|
id: &str,
|
|
label: &str,
|
|
position: usize,
|
|
) -> Result<(), ConfigError> {
|
|
self.transaction(|document| {
|
|
let tables = materialize_mixer_layout(document)?;
|
|
let mut ordered = tables.iter().cloned().collect::<Vec<_>>();
|
|
let mut separator = Table::new();
|
|
separator["kind"] = value("separator");
|
|
separator["id"] = value(id);
|
|
separator["label"] = value(label);
|
|
ordered.insert(position.min(ordered.len()), separator);
|
|
replace_layout_order(tables, ordered);
|
|
Ok(())
|
|
})
|
|
}
|
|
|
|
/// Changes a separator label without rebuilding unrelated layout entries.
|
|
pub fn set_separator_label(&mut self, id: &str, label: &str) -> Result<(), ConfigError> {
|
|
self.transaction(|document| {
|
|
let tables = materialize_mixer_layout(document)?;
|
|
let table = tables
|
|
.iter_mut()
|
|
.find(|table| {
|
|
table.get("kind").and_then(Item::as_str) == Some("separator")
|
|
&& table.get("id").and_then(Item::as_str) == Some(id)
|
|
})
|
|
.ok_or_else(|| {
|
|
ConfigError::validation("mixer_layout", format!("unknown separator {id:?}"))
|
|
})?;
|
|
table["label"] = value(label);
|
|
Ok(())
|
|
})
|
|
}
|
|
|
|
/// Updates separator spacing and decoration without changing its order.
|
|
pub fn set_separator_presentation(
|
|
&mut self,
|
|
id: &str,
|
|
size: SeparatorSize,
|
|
decoration: SeparatorDecoration,
|
|
) -> Result<(), ConfigError> {
|
|
self.transaction(|document| {
|
|
let table = find_table_mut(document, "mixer_layout", id)?;
|
|
if table.get("kind").and_then(Item::as_str) != Some("separator") {
|
|
return Err(ConfigError::validation(
|
|
"mixer_layout",
|
|
"expected separator",
|
|
));
|
|
}
|
|
table["size"] = value(match size {
|
|
SeparatorSize::Slim => "slim",
|
|
SeparatorSize::Standard => "standard",
|
|
SeparatorSize::Thick => "thick",
|
|
SeparatorSize::Fill => "fill",
|
|
});
|
|
table["decoration"] = value(match decoration {
|
|
SeparatorDecoration::Plain => "plain",
|
|
SeparatorDecoration::Line => "line",
|
|
SeparatorDecoration::Double => "double",
|
|
SeparatorDecoration::Box => "box",
|
|
});
|
|
Ok(())
|
|
})
|
|
}
|
|
|
|
/// Removes only the selected presentation separator.
|
|
pub fn remove_separator(&mut self, id: &str) -> Result<(), ConfigError> {
|
|
self.transaction(|document| {
|
|
let tables = materialize_mixer_layout(document)?;
|
|
let index = tables
|
|
.iter()
|
|
.position(|table| {
|
|
table.get("kind").and_then(Item::as_str) == Some("separator")
|
|
&& table.get("id").and_then(Item::as_str) == Some(id)
|
|
})
|
|
.ok_or_else(|| {
|
|
ConfigError::validation("mixer_layout", format!("unknown separator {id:?}"))
|
|
})?;
|
|
tables.remove(index);
|
|
Ok(())
|
|
})
|
|
}
|
|
|
|
/// Hides or restores a fader without changing its target or bindings.
|
|
pub fn set_fader_hidden(&mut self, id: &str, hidden: bool) -> Result<(), ConfigError> {
|
|
self.transaction(|document| {
|
|
let tables = materialize_mixer_layout(document)?;
|
|
let table = tables
|
|
.iter_mut()
|
|
.find(|table| {
|
|
table.get("kind").and_then(Item::as_str) == Some("fader")
|
|
&& table.get("fader").and_then(Item::as_str) == Some(id)
|
|
})
|
|
.ok_or_else(|| {
|
|
ConfigError::validation("mixer_layout", format!("unknown fader {id:?}"))
|
|
})?;
|
|
table["hidden"] = value(hidden);
|
|
Ok(())
|
|
})
|
|
}
|
|
|
|
/// Changes one fader's vertical presentation density.
|
|
pub fn set_fader_density(
|
|
&mut self,
|
|
id: &str,
|
|
density: FaderDensity,
|
|
) -> Result<(), ConfigError> {
|
|
self.transaction(|document| {
|
|
let tables = materialize_mixer_layout(document)?;
|
|
let table = tables
|
|
.iter_mut()
|
|
.find(|table| {
|
|
table.get("kind").and_then(Item::as_str) == Some("fader")
|
|
&& table.get("fader").and_then(Item::as_str) == Some(id)
|
|
})
|
|
.ok_or_else(|| {
|
|
ConfigError::validation("mixer_layout", format!("unknown fader {id:?}"))
|
|
})?;
|
|
table["density"] = value(match density {
|
|
FaderDensity::Slim => "slim",
|
|
FaderDensity::BorderedSlim => "bordered_slim",
|
|
FaderDensity::Standard => "standard",
|
|
FaderDensity::Thick => "thick",
|
|
});
|
|
Ok(())
|
|
})
|
|
}
|
|
|
|
/// Moves a fader or separator, preserving the complete table and its comments.
|
|
pub fn move_layout_entry(&mut self, id: &str, position: usize) -> Result<(), ConfigError> {
|
|
self.transaction(|document| {
|
|
let tables = materialize_mixer_layout(document)?;
|
|
let mut ordered = tables.iter().cloned().collect::<Vec<_>>();
|
|
let index = ordered
|
|
.iter()
|
|
.position(|table| layout_entry_id(table) == Some(id))
|
|
.ok_or_else(|| {
|
|
ConfigError::validation("mixer_layout", format!("unknown layout entry {id:?}"))
|
|
})?;
|
|
let entry = ordered.remove(index);
|
|
ordered.insert(position.min(ordered.len()), entry);
|
|
replace_layout_order(tables, ordered);
|
|
Ok(())
|
|
})
|
|
}
|
|
|
|
/// Adds one validated surface control assignment.
|
|
pub fn add_binding(
|
|
&mut self,
|
|
surface: &str,
|
|
fader: &str,
|
|
action: Action,
|
|
kind: MessageKind,
|
|
channel: u16,
|
|
number: u16,
|
|
) -> Result<(), ConfigError> {
|
|
self.transaction(|document| {
|
|
let bindings = document
|
|
.get_mut("bindings")
|
|
.and_then(Item::as_array_of_tables_mut)
|
|
.ok_or_else(|| ConfigError::validation("bindings", "missing binding array"))?;
|
|
let mut table = Table::new();
|
|
table["surface"] = value(surface);
|
|
table["fader"] = value(fader);
|
|
table["action"] = value(match action {
|
|
Action::Volume => "volume",
|
|
Action::ToggleMute => "toggle_mute",
|
|
});
|
|
if action == Action::ToggleMute {
|
|
table["edge"] = value("press");
|
|
}
|
|
let mut message = InlineTable::new();
|
|
message.insert(
|
|
"kind",
|
|
Value::from(match kind {
|
|
MessageKind::Cc => "cc",
|
|
MessageKind::Note => "note",
|
|
}),
|
|
);
|
|
message.insert("channel", Value::from(i64::from(channel)));
|
|
message.insert("number", Value::from(i64::from(number)));
|
|
table["message"] = value(message);
|
|
bindings.push(table);
|
|
Ok(())
|
|
})
|
|
}
|
|
|
|
/// Replaces all assignments for one fader action with one validated control.
|
|
pub fn set_binding(
|
|
&mut self,
|
|
surface: &str,
|
|
fader: &str,
|
|
action: Action,
|
|
kind: MessageKind,
|
|
channel: u16,
|
|
number: u16,
|
|
) -> Result<(), ConfigError> {
|
|
self.transaction(|document| {
|
|
let bindings = document
|
|
.get_mut("bindings")
|
|
.and_then(Item::as_array_of_tables_mut)
|
|
.ok_or_else(|| ConfigError::validation("bindings", "missing binding array"))?;
|
|
let matching = bindings
|
|
.iter()
|
|
.enumerate()
|
|
.filter_map(|(index, table)| binding_matches(table, fader, action).then_some(index))
|
|
.collect::<Vec<_>>();
|
|
if let Some(first) = matching.first().copied() {
|
|
let table = bindings.get_mut(first).ok_or_else(|| {
|
|
ConfigError::validation("bindings", "binding disappeared during edit")
|
|
})?;
|
|
update_binding_table(table, surface, fader, action, kind, channel, number);
|
|
for index in matching.into_iter().skip(1).rev() {
|
|
bindings.remove(index);
|
|
}
|
|
} else {
|
|
bindings.push(binding_table(surface, fader, action, kind, channel, number));
|
|
}
|
|
Ok(())
|
|
})
|
|
}
|
|
|
|
/// Removes only the selected fader action assignments.
|
|
pub fn remove_bindings(&mut self, fader: &str, action: Action) -> Result<(), ConfigError> {
|
|
self.transaction(|document| {
|
|
let bindings = document
|
|
.get_mut("bindings")
|
|
.and_then(Item::as_array_of_tables_mut)
|
|
.ok_or_else(|| ConfigError::validation("bindings", "missing binding array"))?;
|
|
bindings.retain(|table| !binding_matches(table, fader, action));
|
|
Ok(())
|
|
})
|
|
}
|
|
|
|
/// Returns the current source without consuming the draft.
|
|
#[must_use]
|
|
pub fn source(&self) -> String {
|
|
self.document.to_string()
|
|
}
|
|
|
|
/// Builds a validated runtime profile without consuming the draft.
|
|
pub fn preview(&self) -> Result<Profile, ConfigError> {
|
|
Profile::parse(&self.document.to_string())
|
|
}
|
|
|
|
fn transaction(
|
|
&mut self,
|
|
edit: impl FnOnce(&mut DocumentMut) -> Result<(), ConfigError>,
|
|
) -> Result<(), ConfigError> {
|
|
let mut candidate = self.document.clone();
|
|
edit(&mut candidate)?;
|
|
Profile::parse(&candidate.to_string())?;
|
|
self.document = candidate;
|
|
Ok(())
|
|
}
|
|
|
|
fn remove_table(&mut self, section: &str, id: &str) -> Result<(), ConfigError> {
|
|
self.transaction(|document| {
|
|
let tables = document
|
|
.get_mut(section)
|
|
.and_then(Item::as_array_of_tables_mut)
|
|
.ok_or_else(|| ConfigError::validation(section, "missing table array"))?;
|
|
let index = tables
|
|
.iter()
|
|
.position(|table| table.get("id").and_then(Item::as_str) == Some(id))
|
|
.ok_or_else(|| {
|
|
ConfigError::validation(section, format!("unknown {section} entry {id:?}"))
|
|
})?;
|
|
tables.remove(index);
|
|
Ok(())
|
|
})
|
|
}
|
|
|
|
/// Returns edited TOML only if the complete result remains valid.
|
|
pub fn finish(self) -> Result<String, ConfigError> {
|
|
let output = self.document.to_string();
|
|
Profile::parse(&output)?;
|
|
Ok(output)
|
|
}
|
|
}
|
|
|
|
fn find_table_mut<'a>(
|
|
document: &'a mut DocumentMut,
|
|
section: &str,
|
|
id: &str,
|
|
) -> Result<&'a mut Table, ConfigError> {
|
|
document
|
|
.get_mut(section)
|
|
.and_then(Item::as_array_of_tables_mut)
|
|
.and_then(|tables| {
|
|
tables.iter_mut().find(|table| {
|
|
table
|
|
.get("id")
|
|
.and_then(Item::as_str)
|
|
.is_some_and(|candidate| candidate == id)
|
|
})
|
|
})
|
|
.ok_or_else(|| ConfigError::validation(section, format!("unknown {section} entry {id:?}")))
|
|
}
|
|
|
|
fn materialize_mixer_layout(document: &mut DocumentMut) -> Result<&mut ArrayOfTables, ConfigError> {
|
|
let faders = document
|
|
.get("faders")
|
|
.and_then(Item::as_array_of_tables)
|
|
.ok_or_else(|| ConfigError::validation("faders", "missing fader array"))?
|
|
.iter()
|
|
.filter_map(|table| table.get("id").and_then(Item::as_str).map(str::to_owned))
|
|
.collect::<Vec<_>>();
|
|
|
|
if document.get("mixer_layout").is_none() {
|
|
document["mixer_layout"] = Item::ArrayOfTables(ArrayOfTables::new());
|
|
}
|
|
let tables = document
|
|
.get_mut("mixer_layout")
|
|
.and_then(Item::as_array_of_tables_mut)
|
|
.ok_or_else(|| ConfigError::validation("mixer_layout", "must be an array of tables"))?;
|
|
let present = tables
|
|
.iter()
|
|
.filter(|table| table.get("kind").and_then(Item::as_str) == Some("fader"))
|
|
.filter_map(|table| table.get("fader").and_then(Item::as_str).map(str::to_owned))
|
|
.collect::<std::collections::BTreeSet<_>>();
|
|
for fader in faders {
|
|
if !present.contains(&fader) {
|
|
let mut table = Table::new();
|
|
table["kind"] = value("fader");
|
|
table["fader"] = value(fader);
|
|
table["hidden"] = value(false);
|
|
table["density"] = value("standard");
|
|
tables.push(table);
|
|
}
|
|
}
|
|
Ok(tables)
|
|
}
|
|
|
|
fn replace_layout_order(tables: &mut ArrayOfTables, mut ordered: Vec<Table>) {
|
|
// Parsed tables carry source positions, and toml_edit sorts by those when
|
|
// serializing. Reordering the vector alone therefore undoes a move on
|
|
// save/preview. Give this flat layout array one common source anchor so
|
|
// stable serialization follows its new order, retaining each table's decor.
|
|
if let Some(anchor) = ordered.iter().filter_map(Table::position).min() {
|
|
for table in &mut ordered {
|
|
table.set_position(anchor);
|
|
}
|
|
}
|
|
*tables = ordered.into_iter().collect();
|
|
}
|
|
|
|
fn layout_entry_id(table: &Table) -> Option<&str> {
|
|
match table.get("kind").and_then(Item::as_str) {
|
|
Some("fader") => table.get("fader").and_then(Item::as_str),
|
|
Some("separator") => table.get("id").and_then(Item::as_str),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
fn selector_array(selectors: &[SelectorDraft]) -> Array {
|
|
let mut values = Array::new();
|
|
for selector in selectors {
|
|
values.push(Value::InlineTable(selector_table(selector)));
|
|
}
|
|
values
|
|
}
|
|
|
|
fn selector_table(selector: &SelectorDraft) -> InlineTable {
|
|
let mut inline = InlineTable::new();
|
|
inline.insert("field", Value::from(selector.field.as_str()));
|
|
match &selector.pattern {
|
|
SelectorPattern::Exact(pattern) => {
|
|
inline.insert("exact", Value::from(pattern.as_str()));
|
|
}
|
|
SelectorPattern::Regex(pattern) => {
|
|
inline.insert("regex", Value::from(pattern.as_str()));
|
|
}
|
|
}
|
|
inline
|
|
}
|
|
|
|
fn binding_matches(table: &Table, fader: &str, action: Action) -> bool {
|
|
table.get("fader").and_then(Item::as_str) == Some(fader)
|
|
&& table.get("action").and_then(Item::as_str)
|
|
== Some(match action {
|
|
Action::Volume => "volume",
|
|
Action::ToggleMute => "toggle_mute",
|
|
})
|
|
}
|
|
|
|
fn binding_table(
|
|
surface: &str,
|
|
fader: &str,
|
|
action: Action,
|
|
kind: MessageKind,
|
|
channel: u16,
|
|
number: u16,
|
|
) -> Table {
|
|
let mut table = Table::new();
|
|
update_binding_table(&mut table, surface, fader, action, kind, channel, number);
|
|
table
|
|
}
|
|
|
|
fn update_binding_table(
|
|
table: &mut Table,
|
|
surface: &str,
|
|
fader: &str,
|
|
action: Action,
|
|
kind: MessageKind,
|
|
channel: u16,
|
|
number: u16,
|
|
) {
|
|
let feedback_follows_message = table
|
|
.get("message")
|
|
.and_then(Item::as_inline_table)
|
|
.zip(table.get("feedback").and_then(Item::as_inline_table))
|
|
.is_some_and(|(message, feedback)| {
|
|
message.get("kind").and_then(Value::as_str)
|
|
== feedback.get("kind").and_then(Value::as_str)
|
|
&& message.get("channel").and_then(Value::as_integer)
|
|
== feedback.get("channel").and_then(Value::as_integer)
|
|
&& message.get("number").and_then(Value::as_integer)
|
|
== feedback.get("number").and_then(Value::as_integer)
|
|
});
|
|
table["surface"] = value(surface);
|
|
table["fader"] = value(fader);
|
|
table["action"] = value(match action {
|
|
Action::Volume => "volume",
|
|
Action::ToggleMute => "toggle_mute",
|
|
});
|
|
if action == Action::ToggleMute {
|
|
table["edge"] = value("press");
|
|
} else {
|
|
table.remove("edge");
|
|
}
|
|
let mut message = InlineTable::new();
|
|
message.insert(
|
|
"kind",
|
|
Value::from(match kind {
|
|
MessageKind::Cc => "cc",
|
|
MessageKind::Note => "note",
|
|
}),
|
|
);
|
|
message.insert("channel", Value::from(i64::from(channel)));
|
|
message.insert("number", Value::from(i64::from(number)));
|
|
table["message"] = value(message);
|
|
if feedback_follows_message
|
|
&& let Some(feedback) = table
|
|
.get_mut("feedback")
|
|
.and_then(Item::as_inline_table_mut)
|
|
{
|
|
feedback.insert(
|
|
"kind",
|
|
Value::from(match kind {
|
|
MessageKind::Cc => "cc",
|
|
MessageKind::Note => "note",
|
|
}),
|
|
);
|
|
feedback.insert("channel", Value::from(i64::from(channel)));
|
|
feedback.insert("number", Value::from(i64::from(number)));
|
|
}
|
|
}
|
|
|
|
fn string_array(values: &[&str]) -> Array {
|
|
let mut array = Array::new();
|
|
for item in values {
|
|
array.push(*item);
|
|
}
|
|
array
|
|
}
|
|
|
|
fn target_table(kind: TargetKind, id: &str) -> InlineTable {
|
|
let mut target = InlineTable::new();
|
|
target.insert(
|
|
"kind",
|
|
Value::from(match kind {
|
|
TargetKind::Application => "application",
|
|
TargetKind::Group => "group",
|
|
TargetKind::Output => "output",
|
|
}),
|
|
);
|
|
target.insert("id", Value::from(id));
|
|
target
|
|
}
|