#231 Make compartment-private parameters fully work

main/src/application/group_model.rs

@@ -1,5 +1,6 @@
 use crate::application::{ActivationConditionModel, GroupData};
 use crate::core::{prop, Prop};
+use crate::domain::MappingCompartment;
 use core::fmt;
 use rx_util::UnitEvent;
 use serde::{Deserialize, Serialize};
@@ -10,25 +11,14 @@ use uuid::Uuid;
 /// A mapping group.
 #[derive(Clone, Debug)]
 pub struct GroupModel {
+    compartment: MappingCompartment,
     id: GroupId,
     pub name: Prop<String>,
     pub control_is_enabled: Prop<bool>,
     pub feedback_is_enabled: Prop<bool>,
     pub activation_condition_model: ActivationConditionModel,
 }
 
-impl Default for GroupModel {
-    fn default() -> Self {
-        Self {
-            id: Default::default(),
-            name: Default::default(),
-            control_is_enabled: prop(true),
-            feedback_is_enabled: prop(true),
-            activation_condition_model: ActivationConditionModel::default(),
-        }
-    }
-}
-
 impl fmt::Display for GroupModel {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "{}", self.name.get_ref())
@@ -76,22 +66,37 @@ impl fmt::Display for GroupId {
 }
 
 impl GroupModel {
-    pub fn new_from_ui(name: String) -> Self {
-        Self::new_internal(GroupId::random(), name)
+    pub fn new_from_ui(compartment: MappingCompartment, name: String) -> Self {
+        Self::new_internal(compartment, GroupId::random(), name)
     }
 
-    pub fn new_from_data(id: GroupId) -> Self {
-        Self::new_internal(id, "".to_string())
+    pub fn new_from_data(compartment: MappingCompartment, id: GroupId) -> Self {
+        Self::new_internal(compartment, id, "".to_string())
     }
 
-    fn new_internal(id: GroupId, name: String) -> Self {
+    pub fn default_for_compartment(compartment: MappingCompartment) -> Self {
+        Self {
+            compartment,
+            id: Default::default(),
+            name: Default::default(),
+            control_is_enabled: prop(true),
+            feedback_is_enabled: prop(true),
+            activation_condition_model: ActivationConditionModel::default(),
+        }
+    }
+
+    fn new_internal(compartment: MappingCompartment, id: GroupId, name: String) -> Self {
         Self {
             id,
             name: prop(name),
-            ..Default::default()
+            ..Self::default_for_compartment(compartment)
         }
     }
 
+    pub fn compartment(&self) -> MappingCompartment {
+        self.compartment
+    }
+
     pub fn id(&self) -> GroupId {
         self.id
     }

main/src/application/mapping_model.rs

@@ -363,6 +363,8 @@ impl<'a> MappingModelWithContext<'a> {
     }
 
     fn target_with_context(&self) -> TargetModelWithContext<'_> {
-        self.mapping.target_model.with_context(self.context)
+        self.mapping
+            .target_model
+            .with_context(self.context, self.mapping.compartment)
     }
 }

main/src/application/preset.rs

@@ -53,13 +53,14 @@ fn mapping_has_project_references(mapping: &MappingModel) -> bool {
 }
 
 fn make_mapping_project_independent(mapping: &mut MappingModel, context: ExtendedProcessorContext) {
+    let compartment = mapping.compartment();
     let target = &mut mapping.target_model;
     match target.category.get() {
         TargetCategory::Reaper => {
             let changed_to_track_ignore_fx = if target.supports_fx() {
                 let refers_to_project = target.fx_type.get().refers_to_project();
                 if refers_to_project {
-                    let target_with_context = target.with_context(context);
+                    let target_with_context = target.with_context(context, compartment);
                     let virtual_fx = if target_with_context.fx().ok().as_ref()
                         == Some(context.context.containing_fx())
                     {
@@ -80,7 +81,7 @@ fn make_mapping_project_independent(mapping: &mut MappingModel, context: Extende
                 let new_virtual_track = if changed_to_track_ignore_fx {
                     // Track doesn't matter at all. We change it to <This>. Looks nice.
                     Some(VirtualTrack::This)
-                } else if let Ok(t) = target.with_context(context).effective_track() {
+                } else if let Ok(t) = target.with_context(context, compartment).effective_track() {
                     if let Some(i) = t.index() {
                         Some(VirtualTrack::ByIndex(i))
                     } else {

main/src/application/session.rs

@@ -9,9 +9,9 @@ use crate::domain::{
     MappingCompartment, MappingId, MidiControlInput, MidiFeedbackOutput, NormalMainTask,
     NormalRealTimeTask, OscDeviceId, ParameterArray, ProcessorContext, ProjectionFeedbackValue,
     QualifiedMappingId, RealSource, RealTimeSender, ReaperTarget, TargetValueChangedEvent,
-    VirtualSource, PLUGIN_PARAMETER_COUNT, ZEROED_PLUGIN_PARAMETERS,
+    VirtualSource, COMPARTMENT_PARAMETER_COUNT, PLUGIN_PARAMETER_COUNT, ZEROED_PLUGIN_PARAMETERS,
 };
-use enum_map::EnumMap;
+use enum_map::{enum_map, EnumMap};
 
 use reaper_high::Reaper;
 use rx_util::{BoxedUnitEvent, Event, Notifier, SharedItemEvent, SharedPayload, UnitEvent};
@@ -80,7 +80,7 @@ pub struct Session {
     party_is_over_subject: LocalSubject<'static, (), ()>,
     ui: WrapDebug<Box<dyn SessionUi>>,
     parameters: ParameterArray,
-    parameter_settings: Vec<ParameterSetting>,
+    parameter_settings: EnumMap<MappingCompartment, Vec<ParameterSetting>>,
     controller_preset_manager: Box<dyn PresetManager<PresetType = ControllerPreset>>,
     main_preset_manager: Box<dyn PresetManager<PresetType = MainPreset>>,
     main_preset_link_manager: Box<dyn PresetLinkManager>,
@@ -176,8 +176,12 @@ impl Session {
             active_main_preset_id: None,
             context,
             mappings: Default::default(),
-            default_main_group: Default::default(),
-            default_controller_group: Default::default(),
+            default_main_group: Rc::new(RefCell::new(GroupModel::default_for_compartment(
+                MappingCompartment::MainMappings,
+            ))),
+            default_controller_group: Rc::new(RefCell::new(GroupModel::default_for_compartment(
+                MappingCompartment::ControllerMappings,
+            ))),
             groups: Default::default(),
             everything_changed_subject: Default::default(),
             mapping_list_changed_subject: Default::default(),
@@ -192,8 +196,10 @@ impl Session {
             party_is_over_subject: Default::default(),
             ui: WrapDebug(Box::new(ui)),
             parameters: ZEROED_PLUGIN_PARAMETERS,
-            // TODO-high This should be probably divided per compartment!
-            parameter_settings: vec![Default::default(); PLUGIN_PARAMETER_COUNT as usize],
+            parameter_settings: enum_map! {
+                ControllerMappings => vec![Default::default(); COMPARTMENT_PARAMETER_COUNT as usize],
+                MainMappings => vec![Default::default(); COMPARTMENT_PARAMETER_COUNT as usize],
+            },
             controller_preset_manager: Box::new(controller_manager),
             main_preset_manager: Box::new(main_preset_manager),
             main_preset_link_manager: Box::new(preset_link_manager),
@@ -253,12 +259,16 @@ impl Session {
         })
     }
 
-    pub fn get_parameter_settings(&self, index: u32) -> &ParameterSetting {
-        &self.parameter_settings[index as usize]
+    pub fn get_parameter_settings(
+        &self,
+        compartment: MappingCompartment,
+        index: u32,
+    ) -> &ParameterSetting {
+        &self.parameter_settings[compartment][index as usize]
     }
 
-    pub fn get_parameter_name(&self, index: u32) -> String {
-        let setting = &self.parameter_settings[index as usize];
+    pub fn get_parameter_name(&self, compartment: MappingCompartment, index: u32) -> String {
+        let setting = &self.parameter_settings[compartment][index as usize];
         match &setting.custom_name {
             None => format!("Parameter {}", index + 1),
             Some(n) => n.clone(),
@@ -267,9 +277,10 @@ impl Session {
 
     pub fn set_parameter_settings_without_notification(
         &mut self,
+        compartment: MappingCompartment,
         parameter_settings: Vec<ParameterSetting>,
     ) {
-        self.parameter_settings = parameter_settings;
+        self.parameter_settings[compartment] = parameter_settings;
     }
 
     fn initial_sync(&mut self, weak_session: WeakSession) {
@@ -431,9 +442,10 @@ impl Session {
 
     fn invalidate_fx_indexes_of_mapping_targets(&self) {
         for m in self.all_mappings() {
-            m.borrow_mut()
-                .target_model
-                .invalidate_fx_index(self.extended_context());
+            let mut m = m.borrow_mut();
+            let compartment = m.compartment();
+            m.target_model
+                .invalidate_fx_index(self.extended_context(), compartment);
         }
     }
 
@@ -663,7 +675,7 @@ impl Session {
     }
 
     pub fn add_default_group(&mut self, compartment: MappingCompartment, name: String) -> GroupId {
-        let group = GroupModel::new_from_ui(name);
+        let group = GroupModel::new_from_ui(compartment, name);
         self.add_group(compartment, group)
     }
 
@@ -1373,7 +1385,8 @@ impl Session {
             );
         } else {
             // <None> preset
-            self.default_main_group.replace(Default::default());
+            self.default_main_group
+                .replace(GroupModel::default_for_compartment(compartment));
             self.set_groups_without_notification(compartment, std::iter::empty());
             self.set_mappings_without_notification(compartment, std::iter::empty());
         }

main/src/application/target_model.rs

@@ -155,8 +155,9 @@ impl TargetModel {
     pub fn take_fx_snapshot(
         &self,
         context: ExtendedProcessorContext,
+        compartment: MappingCompartment,
     ) -> Result<FxSnapshot, &'static str> {
-        let fx = self.with_context(context).fx()?;
+        let fx = self.with_context(context, compartment).fx()?;
         let fx_info = fx.info();
         let fx_snapshot = FxSnapshot {
             fx_type: if fx_info.sub_type_expression.is_empty() {
@@ -171,11 +172,15 @@ impl TargetModel {
         Ok(fx_snapshot)
     }
 
-    pub fn invalidate_fx_index(&mut self, context: ExtendedProcessorContext) {
+    pub fn invalidate_fx_index(
+        &mut self,
+        context: ExtendedProcessorContext,
+        compartment: MappingCompartment,
+    ) {
         if !self.supports_fx() {
             return;
         }
-        if let Ok(actual_fx) = self.with_context(context).fx() {
+        if let Ok(actual_fx) = self.with_context(context, compartment).fx() {
             let new_virtual_fx = match self.virtual_fx() {
                 Some(virtual_fx) => {
                     match virtual_fx {
@@ -691,10 +696,12 @@ impl TargetModel {
     pub fn with_context<'a>(
         &'a self,
         context: ExtendedProcessorContext<'a>,
+        compartment: MappingCompartment,
     ) -> TargetModelWithContext<'a> {
         TargetModelWithContext {
             target: self,
             context,
+            compartment,
         }
     }
 
@@ -843,6 +850,7 @@ pub fn get_fx_label(index: u32, fx: &Fx) -> String {
 pub struct TargetModelWithContext<'a> {
     target: &'a TargetModel,
     context: ExtendedProcessorContext<'a>,
+    compartment: MappingCompartment,
 }
 
 impl<'a> TargetModelWithContext<'a> {
@@ -858,7 +866,7 @@ impl<'a> TargetModelWithContext<'a> {
     /// track/FX/parameter) is not available.
     pub fn create_target(&self) -> Result<CompoundMappingTarget, &'static str> {
         let unresolved = self.target.create_target()?;
-        unresolved.resolve(self.context)
+        unresolved.resolve(self.context, self.compartment)
     }
 
     pub fn is_known_to_be_roundable(&self) -> bool {
@@ -874,7 +882,11 @@ impl<'a> TargetModelWithContext<'a> {
     }
     // Returns an error if the FX doesn't exist.
     pub fn fx(&self) -> Result<Fx, &'static str> {
-        get_fx(self.context, &self.target.fx_descriptor()?)
+        get_fx(
+            self.context,
+            &self.target.fx_descriptor()?,
+            self.compartment,
+        )
     }
 
     pub fn project(&self) -> Project {
@@ -886,18 +898,26 @@ impl<'a> TargetModelWithContext<'a> {
         self.target
             .virtual_track()
             .ok_or("virtual track not complete")?
-            .resolve(self.context)
+            .resolve(self.context, self.compartment)
             .map_err(|_| "particular track couldn't be resolved")
     }
 
     // Returns an error if that send (or track) doesn't exist.
     pub fn track_route(&self) -> Result<TrackRoute, &'static str> {
-        get_track_route(self.context, &self.target.track_route_descriptor()?)
+        get_track_route(
+            self.context,
+            &self.target.track_route_descriptor()?,
+            self.compartment,
+        )
     }
 
     // Returns an error if that param (or FX) doesn't exist.
     fn fx_param(&self) -> Result<FxParameter, &'static str> {
-        get_fx_param(self.context, &self.target.fx_parameter_descriptor()?)
+        get_fx_param(
+            self.context,
+            &self.target.fx_parameter_descriptor()?,
+            self.compartment,
+        )
     }
 
     fn route_type_label(&self) -> &'static str {
@@ -928,7 +948,7 @@ impl<'a> TargetModelWithContext<'a> {
 
     fn track_label(&self) -> String {
         if let Some(t) = self.target.virtual_track() {
-            t.with_context(self.context).to_string()
+            t.with_context(self.context, self.compartment).to_string()
         } else {
             "<Undefined>".to_owned()
         }

main/src/domain/conditional_activation.rs

@@ -1,7 +1,5 @@
 use crate::core::eel;
-use crate::domain::{
-    ParameterArray, ParameterSlice, COMPARTMENT_PARAMETER_COUNT, PLUGIN_PARAMETER_COUNT,
-};
+use crate::domain::{ParameterArray, ParameterSlice, COMPARTMENT_PARAMETER_COUNT};
 use std::collections::HashSet;
 
 #[derive(Debug)]

main/src/domain/main_processor.rs

@@ -25,7 +25,7 @@ const FEEDBACK_TASK_BULK_SIZE: usize = 64;
 const CONTROL_TASK_BULK_SIZE: usize = 32;
 const PARAMETER_TASK_BULK_SIZE: usize = 32;
 
-pub const PLUGIN_PARAMETER_COUNT: u32 = 100;
+pub const PLUGIN_PARAMETER_COUNT: u32 = 200;
 pub const COMPARTMENT_PARAMETER_COUNT: u32 = 100;
 pub type ParameterArray = [f32; PLUGIN_PARAMETER_COUNT as usize];
 pub type ParameterSlice = [f32];
@@ -215,10 +215,10 @@ impl<EH: DomainEventHandler> MainProcessor<EH> {
                     let real_time_mappings = mappings
                         .iter_mut()
                         .map(|m| {
-                            m.refresh_all(
-                                ExtendedProcessorContext::new(&self.context, &self.parameters),
+                            m.refresh_all(ExtendedProcessorContext::new(
+                                &self.context,
                                 &self.parameters,
-                            );
+                            ));
                             if m.feedback_is_effectively_on() {
                                 // Mark source as used
                                 unused_sources.remove(&m.qualified_source());
@@ -314,10 +314,10 @@ impl<EH: DomainEventHandler> MainProcessor<EH> {
                         mapping.id()
                     );
                     // Refresh
-                    mapping.refresh_all(
-                        ExtendedProcessorContext::new(&self.context, &self.parameters),
+                    mapping.refresh_all(ExtendedProcessorContext::new(
+                        &self.context,
                         &self.parameters,
-                    );
+                    ));
                     // Sync to real-time processor
                     self.normal_real_time_task_sender
                         .send(NormalRealTimeTask::UpdateSingleMapping(
@@ -551,7 +551,7 @@ impl<EH: DomainEventHandler> MainProcessor<EH> {
                         .handle_event(DomainEvent::UpdatedParameter { index, value });
                     // Mapping activation is supported for both compartments and target activation
                     // might change also in non-virtual controller mappings due to dynamic targets.
-                    for compartment in MappingCompartment::enum_iter() {
+                    if let Some(compartment) = MappingCompartment::by_absolute_param_index(index) {
                         let mut changed_mappings = HashSet::new();
                         let mut unused_sources =
                             self.currently_feedback_enabled_sources(compartment, true);