use crate::change_frame::{decode as decode_frame, ChangeFrame};
use crate::juce_var::Value;
use crate::layout::Layout;
use crate::names::{
AppParam, AudioParam, BuildParam, ChannelParam, CurrentShowParam, DeviceModel, DuckerParam,
EffectsParam, Fader, FxPresetParam, GuiParam, HeadphoneParam, InputSourceParam, MasterParam,
MeterParam, MixMinusesParam, MixOutput, NetworkParam, OutputParam, PadParam, PadRecorderParam,
PlayerParam, RadioParam, RadioRxParam, RadioTxParam, RcSyncMixParam, RecorderParam,
RecordingParam, RecordingsParam, ShowControlParam, ShowParam, SipAdvancedParam,
SipCallSlotsParam, SipCallingParam, SipRegistrationParam, Source, StorageVolumeParam,
StreamerXMixPresetParam, StreamerXStreamMixParam, SystemParam, TestParam, ThemeParam,
WifiScanResultParam,
};
use crate::trigger::decode_phase;
pub use crate::trigger::TriggerPhase;
use crate::valuetree::Node;
#[derive(Debug, Clone, PartialEq)]
#[non_exhaustive]
pub enum DeviceEvent {
InitialState(Vec<DeviceEvent>),
FaderMuteChanged { fader: Fader, muted: bool },
FaderCueChanged { fader: Fader, enabled: bool },
FaderLevelChanged { fader: Fader, level: u8 },
FaderTouched { fader: Fader },
FaderEncoderColourChanged { fader: Fader, colour: Option<i32> },
MixLinkRequested {
source: Source,
mix: MixOutput,
direction: MixLinkDirection,
origin: MixLinkRequestOrigin,
},
FaderAssignmentChanged {
fader: Fader,
source: Option<Source>,
},
ChannelParamChanged {
fader: Fader,
param: ChannelParam,
value: Value,
},
InputSourceParamChanged {
source: Source,
param: InputSourceParam,
value: Value,
},
MasterParamChanged { param: MasterParam, value: Value },
OutputParamChanged { param: OutputParam, value: Value },
DuckerParamChanged { param: DuckerParam, value: Value },
RecorderParamChanged { param: RecorderParam, value: Value },
PlayerParamChanged { param: PlayerParam, value: Value },
HeadphoneParamChanged {
headphone: u8,
param: HeadphoneParam,
value: Value,
},
EffectsParamChanged {
effects: u8,
param: EffectsParam,
value: Value,
},
GuiParamChanged { param: GuiParam, value: Value },
PadParamChanged {
pad: u8,
param: PadParam,
value: Value,
},
SystemParamChanged { param: SystemParam, value: Value },
MixLevelChanged {
source: Source,
mix: MixOutput,
anchor: f32,
value: f32,
},
MixMuteChanged {
source: Source,
mix: MixOutput,
muted: bool,
},
MixLinkChanged {
source: Source,
mix: MixOutput,
linked: bool,
},
MixDisabledChanged {
source: Source,
mix: MixOutput,
disabled: bool,
},
NetworkParamChanged { param: NetworkParam, value: Value },
RecordingsParamChanged {
param: RecordingsParam,
value: Value,
},
RecordingParamChanged {
recording: u8,
param: RecordingParam,
value: Value,
},
StorageVolumeParamChanged {
volume: u8,
param: StorageVolumeParam,
value: Value,
},
PotLevelChanged { pot: u8, level: u8 },
PadButtonPressed { button: u8, pressed: bool },
MutePressed { button: u8, pressed: bool },
AudioParamChanged { param: AudioParam, value: Value },
BuildParamChanged { param: BuildParam, value: Value },
AppParamChanged { param: AppParam, value: Value },
ThemeParamChanged { param: ThemeParam, value: Value },
CurrentShowParamChanged {
param: CurrentShowParam,
value: Value,
},
ShowParamChanged {
show: u8,
param: ShowParam,
value: Value,
},
ShowControlParamChanged {
param: ShowControlParam,
value: Value,
},
MeterParamChanged {
meter: u8,
param: MeterParam,
value: Value,
},
EncoderPressed { encoder: u8, pressed: bool },
SoloPressed { button: u8, pressed: bool },
RecButtonPressed { pressed: bool },
EmergencyMuteChanged { active: bool },
SipCallingParamChanged {
param: SipCallingParam,
value: Value,
},
SipRegistrationParamChanged {
registration: u8,
param: SipRegistrationParam,
value: Value,
},
SipCallSlotsParamChanged {
slot: u8,
param: SipCallSlotsParam,
value: Value,
},
SipAdvancedParamChanged {
param: SipAdvancedParam,
value: Value,
},
StreamerXMixPresetParamChanged {
preset: u8,
param: StreamerXMixPresetParam,
value: Value,
},
StreamerXStreamMixParamChanged {
stream: u8,
param: StreamerXStreamMixParam,
value: Value,
},
FxPresetParamChanged {
preset: u8,
param: FxPresetParam,
value: Value,
},
PadRecorderParamChanged {
pad_recorder: u8,
param: PadRecorderParam,
value: Value,
},
TestParamChanged { param: TestParam, value: Value },
WifiScanResultChanged {
slot: u8,
param: WifiScanResultParam,
value: Value,
},
RadioParamChanged { param: RadioParam, value: Value },
RadioTxParamChanged {
tx: u8,
param: RadioTxParam,
value: Value,
},
RadioRxParamChanged {
rx: u8,
param: RadioRxParam,
value: Value,
},
MixMinusesParamChanged {
minuses: u8,
param: MixMinusesParam,
value: Value,
},
RcSyncMixParamChanged {
mix: u8,
param: RcSyncMixParam,
value: Value,
},
LayoutInvalidated,
Unknown {
prop_name: String,
path: Vec<u32>,
value: Option<Value>,
},
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MixLinkDirection {
Link,
Unlink,
}
pub type MixLinkRequestOrigin = TriggerPhase;
pub fn decode_event(payload: &[u8], layout: &Layout) -> Option<DeviceEvent> {
let frame = decode_frame(payload)?;
Some(decode_change_frame(frame, layout))
}
pub fn decode_event_from_frame(frame: ChangeFrame, layout: &Layout) -> DeviceEvent {
decode_change_frame(frame, layout)
}
fn decode_change_frame(frame: ChangeFrame, layout: &Layout) -> DeviceEvent {
match frame {
ChangeFrame::FullSync { root } => {
DeviceEvent::InitialState(extract_initial_state(&root, layout))
}
ChangeFrame::ChildAdded { .. }
| ChangeFrame::ChildRemoved { .. }
| ChangeFrame::ChildMoved { .. } => DeviceEvent::LayoutInvalidated,
ChangeFrame::PropertyChanged { path, name, value } => {
decode_property(&path, &name, Some(value), layout)
}
ChangeFrame::PropertyRemoved { path, name } => decode_property(&path, &name, None, layout),
}
}
fn decode_property(path: &[u32], name: &str, value: Option<Value>, layout: &Layout) -> DeviceEvent {
let model = layout.model();
if let Some(fader) = layout
.channel_index_from_path(path)
.and_then(|idx| Fader::from_index(model, idx))
{
match name {
"channelOutputMute" => {
if let Some(Value::Bool(muted)) = value {
return DeviceEvent::FaderMuteChanged { fader, muted };
}
}
"channelCueEnable" => {
if let Some(Value::Bool(enabled)) = value {
return DeviceEvent::FaderCueChanged { fader, enabled };
}
}
"channelInputSource" => {
let source = value
.as_ref()
.and_then(Value::as_int)
.filter(|&s| s >= 0)
.and_then(|s| u8::try_from(s).ok())
.and_then(Source::from_protocol);
return DeviceEvent::FaderAssignmentChanged { fader, source };
}
_ => {}
}
}
if let Some(fader) = layout
.fader_index_from_path(path)
.and_then(|idx| Fader::from_index(model, idx))
{
if name == "faderLevel" {
if let Some(v) = &value {
if let Some(level_i64) = v.as_int() {
let level = level_i64.clamp(0, 127) as u8;
return DeviceEvent::FaderLevelChanged { fader, level };
}
}
}
}
if let Some((source, mix)) = layout
.mix_cell_from_path(path)
.and_then(|(s, m)| Some((Source::from_protocol(s)?, MixOutput::from_protocol(m)?)))
{
match name {
"mixMute" => {
if let Some(Value::Bool(muted)) = value {
return DeviceEvent::MixMuteChanged { source, mix, muted };
}
}
"mixLink" => {
if let Some(Value::Bool(linked)) = value {
return DeviceEvent::MixLinkChanged {
source,
mix,
linked,
};
}
}
"mixDisabled" => {
if let Some(Value::Bool(disabled)) = value {
return DeviceEvent::MixDisabledChanged {
source,
mix,
disabled,
};
}
}
"mixLevelWithAnchor" => {
if let Some(Value::String(s)) = &value {
if let Some((anchor, value)) = parse_mix_level(s) {
return DeviceEvent::MixLevelChanged {
source,
mix,
anchor,
value,
};
}
}
}
"mixLinkRequest" | "mixUnlinkRequest" => {
if let Some(origin) = value.as_ref().and_then(decode_phase) {
let direction = if name == "mixLinkRequest" {
MixLinkDirection::Link
} else {
MixLinkDirection::Unlink
};
return DeviceEvent::MixLinkRequested {
source,
mix,
direction,
origin,
};
}
}
_ => {}
}
}
if name == "encoderSignal" {
if let Some(&raw) = path.first() {
if raw < layout.fader_count() as u32 {
if let Some(fader) = Fader::from_index(model, raw as u8) {
return DeviceEvent::FaderTouched { fader };
}
}
}
}
if name == "encoderColour" {
if let Some(&raw) = path.first() {
if raw < layout.fader_count() as u32 {
if let Some(fader) = Fader::from_index(model, raw as u8) {
if let Some(i) = value.as_ref().and_then(Value::as_int) {
let colour = if i < 0 { None } else { Some(i as i32) };
return DeviceEvent::FaderEncoderColourChanged { fader, colour };
}
}
}
}
}
if name == "channelInputSource" {
let fader_opt = layout
.channel_index_from_path(path)
.and_then(|idx| Fader::from_index(model, idx))
.or_else(|| {
path.first()
.and_then(|raw| raw.checked_sub(layout.first_channel()))
.filter(|&offset| offset % 6 == 0)
.map(|offset| offset / 6)
.filter(|&idx| idx < layout.channel_count() as u32)
.and_then(|idx| Fader::from_index(model, idx as u8))
});
if let Some(fader) = fader_opt {
let source = value
.as_ref()
.and_then(Value::as_int)
.filter(|&s| s >= 0)
.and_then(|s| u8::try_from(s).ok())
.and_then(Source::from_protocol);
return DeviceEvent::FaderAssignmentChanged { fader, source };
}
}
if path.len() == 2 && path[0] == layout.physical_interface_idx() {
let child = path[1] as u8;
match name {
"potLevel" => {
if let Some(Value::Int(level)) = value.as_ref() {
return DeviceEvent::PotLevelChanged {
pot: child,
level: (*level).clamp(0, 127) as u8,
};
}
}
"padButtonPressed" => {
if let Some(Value::Bool(pressed)) = value.as_ref() {
return DeviceEvent::PadButtonPressed {
button: child,
pressed: *pressed,
};
}
}
"mutePressed" => {
if let Some(Value::Bool(pressed)) = value.as_ref() {
return DeviceEvent::MutePressed {
button: child,
pressed: *pressed,
};
}
}
"soloPressed" => {
if let Some(Value::Bool(pressed)) = value.as_ref() {
return DeviceEvent::SoloPressed {
button: child,
pressed: *pressed,
};
}
}
"encoderPressed" => {
if let Some(Value::Bool(pressed)) = value.as_ref() {
return DeviceEvent::EncoderPressed {
encoder: child,
pressed: *pressed,
};
}
}
"recButtonPressed" => {
if let Some(Value::Bool(pressed)) = value.as_ref() {
return DeviceEvent::RecButtonPressed { pressed: *pressed };
}
}
_ => {}
}
}
if path.len() == 1 && name == "emergencyMuteActive" {
if let Some(Value::Bool(active)) = value.as_ref() {
return DeviceEvent::EmergencyMuteChanged { active: *active };
}
}
if let Some(param) = NetworkParam::from_known_name(name) {
if let Some(value) = value {
return DeviceEvent::NetworkParamChanged { param, value };
}
}
if path.len() == 1 {
if let Some(param) = RecordingsParam::from_known_name(name) {
if let Some(value) = value {
return DeviceEvent::RecordingsParamChanged { param, value };
}
}
}
if path.len() == 2 {
if let Some(param) = RecordingParam::from_known_name(name) {
if let Some(value) = value {
return DeviceEvent::RecordingParamChanged {
recording: path[1] as u8,
param,
value,
};
}
}
if let Some(param) = StorageVolumeParam::from_known_name(name) {
if let Some(value) = value {
return DeviceEvent::StorageVolumeParamChanged {
volume: path[1] as u8,
param,
value,
};
}
}
}
if path.len() == 1 {
if let Some(param) = AudioParam::from_known_name(name) {
if let Some(value) = value {
return DeviceEvent::AudioParamChanged { param, value };
}
}
if let Some(param) = BuildParam::from_known_name(name) {
if let Some(value) = value {
return DeviceEvent::BuildParamChanged { param, value };
}
}
if let Some(param) = AppParam::from_known_name(name) {
if let Some(value) = value {
return DeviceEvent::AppParamChanged { param, value };
}
}
if let Some(param) = ThemeParam::from_known_name(name) {
if let Some(value) = value {
return DeviceEvent::ThemeParamChanged { param, value };
}
}
if let Some(param) = CurrentShowParam::from_known_name(name) {
if let Some(value) = value {
return DeviceEvent::CurrentShowParamChanged { param, value };
}
}
if let Some(param) = ShowControlParam::from_known_name(name) {
if let Some(value) = value {
return DeviceEvent::ShowControlParamChanged { param, value };
}
}
}
if path.len() == 2 {
if let Some(param) = ShowParam::from_known_name(name) {
if let Some(value) = value {
return DeviceEvent::ShowParamChanged {
show: path[1] as u8,
param,
value,
};
}
}
if path[0] != layout.physical_interface_idx() {
if let Some(param) = MeterParam::from_known_name(name) {
if let Some(value) = value {
return DeviceEvent::MeterParamChanged {
meter: path[1] as u8,
param,
value,
};
}
}
}
}
if layout.is_sip_calling_path(path) {
if let Some(param) = SipCallingParam::from_known_name(name) {
if let Some(value) = value {
return DeviceEvent::SipCallingParamChanged { param, value };
}
}
}
if layout.is_sip_advanced_path(path) {
if let Some(param) = SipAdvancedParam::from_known_name(name) {
if let Some(value) = value {
return DeviceEvent::SipAdvancedParamChanged { param, value };
}
}
}
if let Some(reg) = layout.sip_registration_index_from_path(path) {
if let Some(param) = SipRegistrationParam::from_known_name(name) {
if let Some(value) = value {
return DeviceEvent::SipRegistrationParamChanged {
registration: reg,
param,
value,
};
}
}
}
if let Some(slot) = layout.sip_call_slots_index_from_path(path) {
if let Some(param) = SipCallSlotsParam::from_known_name(name) {
if let Some(value) = value {
return DeviceEvent::SipCallSlotsParamChanged { slot, param, value };
}
}
}
if let Some(param) = StreamerXMixPresetParam::from_known_name(name) {
if let Some(value) = value {
let preset = path.last().copied().unwrap_or(0) as u8;
return DeviceEvent::StreamerXMixPresetParamChanged {
preset,
param,
value,
};
}
}
if let Some(param) = StreamerXStreamMixParam::from_known_name(name) {
if let Some(value) = value {
let stream = path.last().copied().unwrap_or(0) as u8;
return DeviceEvent::StreamerXStreamMixParamChanged {
stream,
param,
value,
};
}
}
if let Some(param) = FxPresetParam::from_known_name(name) {
if let Some(value) = value {
let preset = path.last().copied().unwrap_or(0) as u8;
return DeviceEvent::FxPresetParamChanged {
preset,
param,
value,
};
}
}
if let Some(param) = PadRecorderParam::from_known_name(name) {
if let Some(value) = value {
let pad_recorder = path.last().copied().unwrap_or(0) as u8;
return DeviceEvent::PadRecorderParamChanged {
pad_recorder,
param,
value,
};
}
}
if let Some(param) = TestParam::from_known_name(name) {
if let Some(value) = value {
return DeviceEvent::TestParamChanged { param, value };
}
}
if let Some(param) = WifiScanResultParam::from_known_name(name) {
if let Some(value) = value {
let slot = path.last().copied().unwrap_or(0) as u8;
return DeviceEvent::WifiScanResultChanged { slot, param, value };
}
}
if let Some(param) = RadioParam::from_known_name(name) {
if let Some(value) = value {
return DeviceEvent::RadioParamChanged { param, value };
}
}
if let Some(param) = RadioTxParam::from_known_name(name) {
if let Some(value) = value {
let tx = path.last().copied().unwrap_or(0) as u8;
return DeviceEvent::RadioTxParamChanged { tx, param, value };
}
}
if let Some(param) = RadioRxParam::from_known_name(name) {
if let Some(value) = value {
let rx = path.last().copied().unwrap_or(0) as u8;
return DeviceEvent::RadioRxParamChanged { rx, param, value };
}
}
if let Some(minuses) = layout.mix_minuses_index_from_path(path) {
if let Some(param) = MixMinusesParam::from_known_name(name) {
if let Some(value) = value {
return DeviceEvent::MixMinusesParamChanged {
minuses,
param,
value,
};
}
}
}
if let Some(mix) = layout.rcsync_mix_index_from_path(path) {
if let Some(param) = RcSyncMixParam::from_known_name(name) {
if let Some(value) = value {
return DeviceEvent::RcSyncMixParamChanged { mix, param, value };
}
}
}
match (resolve_param_target(path, name, layout, model), value) {
(Some(ParamTarget::Channel(fader)), Some(value)) => DeviceEvent::ChannelParamChanged {
fader,
param: ChannelParam::from_name(name),
value,
},
(Some(ParamTarget::InputSource(source)), Some(value)) => {
DeviceEvent::InputSourceParamChanged {
source,
param: InputSourceParam::from_name(name),
value,
}
}
(Some(ParamTarget::Master), Some(value)) => DeviceEvent::MasterParamChanged {
param: MasterParam::from_name(name),
value,
},
(Some(ParamTarget::Output), Some(value)) => DeviceEvent::OutputParamChanged {
param: OutputParam::from_name(name),
value,
},
(Some(ParamTarget::Ducker), Some(value)) => DeviceEvent::DuckerParamChanged {
param: DuckerParam::from_name(name),
value,
},
(Some(ParamTarget::Recorder), Some(value)) => DeviceEvent::RecorderParamChanged {
param: RecorderParam::from_name(name),
value,
},
(Some(ParamTarget::Player), Some(value)) => DeviceEvent::PlayerParamChanged {
param: PlayerParam::from_name(name),
value,
},
(Some(ParamTarget::Headphone(headphone)), Some(value)) => {
DeviceEvent::HeadphoneParamChanged {
headphone,
param: HeadphoneParam::from_name(name),
value,
}
}
(Some(ParamTarget::Effects(effects)), Some(value)) => DeviceEvent::EffectsParamChanged {
effects,
param: EffectsParam::from_name(name),
value,
},
(Some(ParamTarget::Gui), Some(value)) => DeviceEvent::GuiParamChanged {
param: GuiParam::from_name(name),
value,
},
(Some(ParamTarget::Pad(pad)), Some(value)) => DeviceEvent::PadParamChanged {
pad,
param: PadParam::from_name(name),
value,
},
(Some(ParamTarget::System), Some(value)) => DeviceEvent::SystemParamChanged {
param: SystemParam::from_name(name),
value,
},
(_, value) => DeviceEvent::Unknown {
prop_name: name.to_string(),
path: path.to_vec(),
value,
},
}
}
enum ParamTarget {
Channel(Fader),
InputSource(Source),
Master,
Output,
Ducker,
Recorder,
Player,
Headphone(u8),
Effects(u8),
Gui,
Pad(u8),
System,
}
fn resolve_param_target(
path: &[u32],
name: &str,
layout: &Layout,
model: DeviceModel,
) -> Option<ParamTarget> {
if !matches!(
name,
"channelOutputMute" | "channelCueEnable" | "channelInputSource"
) {
if let Some(fader) = layout
.channel_index_from_path(path)
.and_then(|idx| Fader::from_index(model, idx))
{
return Some(ParamTarget::Channel(fader));
}
}
if let Some(source) = layout
.input_source_index_from_path(path)
.and_then(Source::from_protocol)
{
return Some(ParamTarget::InputSource(source));
}
if layout.is_master_channel_path(path) {
return Some(ParamTarget::Master);
}
if layout.is_output_path(path) {
return Some(ParamTarget::Output);
}
if layout.is_ducker_path(path) {
return Some(ParamTarget::Ducker);
}
if layout.is_recorder_path(path) {
return Some(ParamTarget::Recorder);
}
if layout.is_player_path(path) {
return Some(ParamTarget::Player);
}
if let Some(headphone) = layout.headphone_index_from_path(path) {
return Some(ParamTarget::Headphone(headphone));
}
if let Some(effects) = layout.effects_index_from_path(path) {
return Some(ParamTarget::Effects(effects));
}
if layout.is_gui_path(path) {
return Some(ParamTarget::Gui);
}
if let Some(pad) = layout.pad_index_from_path(path) {
return Some(ParamTarget::Pad(pad));
}
if layout.is_system_path(path) {
return Some(ParamTarget::System);
}
None
}
fn parse_mix_level(s: &str) -> Option<(f32, f32)> {
let anchor = s.split('|').next()?.parse().ok()?;
let value = s.split('|').next_back()?.parse().ok()?;
Some((anchor, value))
}
pub fn extract_initial_state(root: &Node, layout: &Layout) -> Vec<DeviceEvent> {
let mut out = Vec::new();
let model = layout.model();
if let Some(phys) = root.children.iter().find(|n| n.name == "PHYSICALINTERFACE") {
let mut fader_idx: u8 = 0;
for child in &phys.children {
if child.name != "FADER" {
continue;
}
if let (Some(fader), Some(level)) = (
Fader::from_index(model, fader_idx),
int_prop(child, "faderLevel"),
) {
out.push(DeviceEvent::FaderLevelChanged {
fader,
level: level.clamp(0, 127) as u8,
});
}
fader_idx = fader_idx.saturating_add(1);
}
}
let mut channel_idx: u8 = 0;
for child in &root.children {
if child.name != "CHANNEL" {
continue;
}
if let Some(fader) = Fader::from_index(model, channel_idx) {
if let Some(muted) = bool_prop(child, "channelOutputMute") {
out.push(DeviceEvent::FaderMuteChanged { fader, muted });
}
if let Some(enabled) = bool_prop(child, "channelCueEnable") {
out.push(DeviceEvent::FaderCueChanged { fader, enabled });
}
if let Some(source_i) = int_prop(child, "channelInputSource") {
out.push(DeviceEvent::FaderAssignmentChanged {
fader,
source: if source_i < 0 {
None
} else {
u8::try_from(source_i).ok().and_then(Source::from_protocol)
},
});
}
for p in &child.properties {
if matches!(
p.name.as_str(),
"channelOutputMute" | "channelCueEnable" | "channelInputSource"
) {
continue;
}
out.push(DeviceEvent::ChannelParamChanged {
fader,
param: ChannelParam::from_name(&p.name),
value: p.value.clone(),
});
}
}
channel_idx = channel_idx.saturating_add(1);
}
let mut mix_counter: u32 = 0;
let per_source = layout.mix_count_per_source() as u32;
for child in &root.children {
if child.name != "MIX" {
continue;
}
let source_idx = (mix_counter / per_source) as u8;
let mix_idx = (mix_counter % per_source) as u8;
mix_counter += 1;
let (source, mix) = match (
Source::from_protocol(source_idx),
MixOutput::from_protocol(mix_idx),
) {
(Some(s), Some(m)) => (s, m),
_ => continue,
};
if let Some(level_s) = string_prop(child, "mixLevelWithAnchor") {
if let Some((anchor, value)) = parse_mix_level(level_s) {
out.push(DeviceEvent::MixLevelChanged {
source,
mix,
anchor,
value,
});
}
}
if let Some(muted) = bool_prop(child, "mixMute") {
out.push(DeviceEvent::MixMuteChanged { source, mix, muted });
}
if let Some(linked) = bool_prop(child, "mixLink") {
out.push(DeviceEvent::MixLinkChanged {
source,
mix,
linked,
});
}
if let Some(disabled) = bool_prop(child, "mixDisabled") {
out.push(DeviceEvent::MixDisabledChanged {
source,
mix,
disabled,
});
}
}
let mut input_source_idx: u32 = 0;
for child in &root.children {
if child.name != "INPUTSOURCE" {
continue;
}
let ordinal = input_source_idx;
input_source_idx += 1;
let source = match u8::try_from(ordinal).ok().and_then(Source::from_protocol) {
Some(s) => s,
None => continue,
};
for p in &child.properties {
out.push(DeviceEvent::InputSourceParamChanged {
source,
param: InputSourceParam::from_name(&p.name),
value: p.value.clone(),
});
}
}
if let Some(node) = root.children.iter().find(|c| c.name == "MASTERCHANNEL") {
for p in &node.properties {
out.push(DeviceEvent::MasterParamChanged {
param: MasterParam::from_name(&p.name),
value: p.value.clone(),
});
}
}
if let Some(node) = root.children.iter().find(|c| c.name == "OUTPUT") {
for p in &node.properties {
out.push(DeviceEvent::OutputParamChanged {
param: OutputParam::from_name(&p.name),
value: p.value.clone(),
});
}
}
if let Some(node) = root.children.iter().find(|c| c.name == "DUCKER") {
for p in &node.properties {
out.push(DeviceEvent::DuckerParamChanged {
param: DuckerParam::from_name(&p.name),
value: p.value.clone(),
});
}
}
if let Some(node) = root.children.iter().find(|c| c.name == "RECORDER") {
for p in &node.properties {
out.push(DeviceEvent::RecorderParamChanged {
param: RecorderParam::from_name(&p.name),
value: p.value.clone(),
});
}
}
if let Some(node) = root.children.iter().find(|c| c.name == "PLAYER") {
for p in &node.properties {
out.push(DeviceEvent::PlayerParamChanged {
param: PlayerParam::from_name(&p.name),
value: p.value.clone(),
});
}
}
let mut headphone_idx: u8 = 0;
for child in &root.children {
if child.name != "HEADPHONE" {
continue;
}
let headphone = headphone_idx;
headphone_idx = headphone_idx.saturating_add(1);
for p in &child.properties {
out.push(DeviceEvent::HeadphoneParamChanged {
headphone,
param: HeadphoneParam::from_name(&p.name),
value: p.value.clone(),
});
}
}
let mut effects_idx: u8 = 0;
let mut seen_effects = false;
for child in &root.children {
if child.name != "EFFECTS_PARAMETERS" {
if seen_effects {
break;
}
continue;
}
seen_effects = true;
let effects = effects_idx;
effects_idx = effects_idx.saturating_add(1);
for p in &child.properties {
out.push(DeviceEvent::EffectsParamChanged {
effects,
param: EffectsParam::from_name(&p.name),
value: p.value.clone(),
});
}
}
if let Some(node) = root.children.iter().find(|c| c.name == "GUI") {
for p in &node.properties {
out.push(DeviceEvent::GuiParamChanged {
param: GuiParam::from_name(&p.name),
value: p.value.clone(),
});
}
}
if let Some(soundpads) = root.children.iter().find(|c| c.name == "SOUNDPADS") {
let mut pad_idx: u8 = 0;
let mut seen_pad = false;
for child in &soundpads.children {
if child.name != "PAD" {
if seen_pad {
break;
}
continue;
}
seen_pad = true;
let pad = pad_idx;
pad_idx = pad_idx.saturating_add(1);
for p in &child.properties {
out.push(DeviceEvent::PadParamChanged {
pad,
param: PadParam::from_name(&p.name),
value: p.value.clone(),
});
}
}
}
if let Some(node) = root.children.iter().find(|c| c.name == "SYSTEM") {
for p in &node.properties {
out.push(DeviceEvent::SystemParamChanged {
param: SystemParam::from_name(&p.name),
value: p.value.clone(),
});
}
}
out
}
fn int_prop(node: &Node, name: &str) -> Option<i64> {
node.properties
.iter()
.find(|p| p.name == name)
.and_then(|p| p.value.as_int())
}
fn bool_prop(node: &Node, name: &str) -> Option<bool> {
node.properties
.iter()
.find(|p| p.name == name)
.and_then(|p| p.value.as_bool())
}
fn string_prop<'a>(node: &'a Node, name: &str) -> Option<&'a str> {
node.properties
.iter()
.find(|p| p.name == name)
.and_then(|p| match &p.value {
Value::String(s) => Some(s.as_str()),
_ => None,
})
}
#[cfg(test)]
#[path = "events_tests.rs"]
mod tests;