gearmulator

Emulation of classic VA synths of the late 90s/2000s that are based on Motorola 56300 family DSPs
Log | Files | Refs | Submodules | README | LICENSE

parameterlocking.cpp (3239B)

      1 #include "parameterlocking.h"
      2 
      3 #include <cassert>
      4 
      5 #include "controller.h"
      6 
      7 namespace pluginLib
      8 {
      9 	ParameterLocking::ParameterLocking(Controller& _controller) : m_controller(_controller)
     10 	{
     11 	}
     12 
     13 	bool ParameterLocking::lockRegion(const uint8_t _part, const std::string& _id)
     14 	{
     15 		auto& lockedRegions = getLockedRegions(_part);
     16 
     17 		if(lockedRegions.find(_id) != lockedRegions.end())
     18 			return true;
     19 
     20 		auto& regions = m_controller.getParameterDescriptions().getRegions();
     21 
     22 		const auto it = regions.find(_id);
     23 
     24 		if(it == regions.end())
     25 			return false;
     26 
     27 		lockedRegions.insert(_id);
     28 
     29 		setParametersLocked(it->second, _part, true);
     30 
     31 		return true;
     32 	}
     33 
     34 	bool ParameterLocking::unlockRegion(const uint8_t _part, const std::string& _id)
     35 	{
     36 		auto& lockedRegions = getLockedRegions(_part);
     37 
     38 		if(!lockedRegions.erase(_id))
     39 			return false;
     40 
     41 		auto& regions = m_controller.getParameterDescriptions().getRegions();
     42 
     43 		const auto it = regions.find(_id);
     44 
     45 		if(it == regions.end())
     46 			return false;
     47 
     48 		lockedRegions.erase(_id);
     49 
     50 		setParametersLocked(it->second, _part, false);
     51 
     52 		return true;
     53 	}
     54 
     55 	const std::set<std::string>& ParameterLocking::getLockedRegions(const uint8_t _part) const
     56 	{
     57 		return m_lockedRegions[_part];
     58 	}
     59 
     60 	bool ParameterLocking::isRegionLocked(const uint8_t _part, const std::string& _id)
     61 	{
     62 		return m_lockedRegions[_part].find(_id) != m_lockedRegions[_part].end();
     63 	}
     64 
     65 	std::unordered_set<std::string> ParameterLocking::getLockedParameterNames(const uint8_t _part) const
     66 	{
     67 		if(m_lockedRegions[_part].empty())
     68 			return {};
     69 
     70 		std::unordered_set<std::string> result;
     71 
     72 		auto& regions = m_controller.getParameterDescriptions().getRegions();
     73 
     74 		for (const auto& name : m_lockedRegions[_part])
     75 		{
     76 			const auto& it = regions.find(name);
     77 			if(it == regions.end())
     78 				continue;
     79 
     80 			const auto& region = it->second;
     81 			for (const auto& itParam : region.getParams())
     82 				result.insert(itParam.first);
     83 		}
     84 
     85 		return result;
     86 	}
     87 
     88 	std::unordered_set<const Parameter*> ParameterLocking::getLockedParameters(const uint8_t _part) const
     89 	{
     90 		const auto paramNames = getLockedParameterNames(_part);
     91 
     92 		std::unordered_set<const Parameter*> results;
     93 
     94 		for (const auto& paramName : paramNames)
     95 		{
     96 			const auto* p = m_controller.getParameter(paramName, _part);
     97 			assert(p != nullptr);
     98 			results.insert(p);
     99 		}
    100 
    101 		return results;
    102 	}
    103 
    104 	bool ParameterLocking::isParameterLocked(const uint8_t _part, const std::string& _name) const
    105 	{
    106 		auto& regions = m_controller.getParameterDescriptions().getRegions();
    107 
    108 		const auto& lockedRegions = getLockedRegions(_part);
    109 
    110 		for (const auto& region : lockedRegions)
    111 		{
    112 			const auto& it = regions.find(region);
    113 			if(it == regions.end())
    114 				continue;
    115 
    116 			if(it->second.containsParameter(_name))
    117 				return true;
    118 		}
    119 		return false;
    120 	}
    121 
    122 	void ParameterLocking::setParametersLocked(const ParameterRegion& _parameterRegion, const uint8_t _part, const bool _locked) const
    123 	{
    124 		for (const auto& param : _parameterRegion.getParams())
    125 		{
    126 			// if a region is unlocked but other regions still lock the same parameter, do nothing
    127 			if(!_locked && isParameterLocked(_part, param.first))
    128 				continue;
    129 
    130 			if(auto* p = m_controller.getParameter(param.first, _part))
    131 				p->setLocked(_locked);
    132 		}
    133 	}
    134 }