void MLPluginProcessor::setDefaultParameters()
{
if (mEngine.getCompileStatus() == MLProc::OK)
{
// set default for each parameter.
const unsigned numParams = getNumParameters();
for(unsigned i=0; i<numParams; ++i)
{
MLPublishedParamPtr paramPtr = getParameterPtr(i);
MLSymbol paramType = paramPtr->getType();
if(paramType == "float")
{
float defaultVal = getParameterDefaultValue(i);
setPropertyImmediate(getParameterAlias(i), defaultVal);
}
else if (paramType == "string")
{
// unimplemented
}
else if (paramType == "signal")
{
const MLProperty& p = getProperty(getParameterAlias(i));
if (p.getType() == MLProperty::kSignalProperty)
{
// TODO set up defaults for signal params once we are loading from JSON
// right now we clear to zero
MLSignal defaultSignal(p.getSignalValue());
defaultSignal.clear();
setPropertyImmediate(getParameterAlias(i), defaultSignal);
}
}
}
}
}
// set plugin parameter by index. Typically called by the host wrapper
//
void MLPluginProcessor::setParameter (int index, float newValue)
{
if (index < 0) return;
mEngine.setPublishedParam(index, newValue);
mHasParametersSet = true;
setPropertyImmediate(getParameterAlias(index), newValue);
}
// set default value for each scalar parameter. needed before loading
// patches, which are only required to store differences from these
// default values.
void MLPluginProcessor::setDefaultParameters()
{
if (mEngine.getCompileStatus() == MLProc::OK)
{
// set default for each parameter.
const unsigned numParams = getNumParameters();
for(unsigned i=0; i<numParams; ++i)
{
float defaultVal = getParameterDefault(i);
setPropertyImmediate(getParameterAlias(i), defaultVal);
}
}
}
void MLMultiSlider::sendSliderAction (float val, int selector)
{
ml::Symbol sliderName = ml::textUtils::addFinalNumber("value", selector);
float currentValue = getFloatProperty(sliderName);
float newValue = constrainedValue(val);
if (currentValue != newValue)
{
ml::Symbol targetPropertyName = ml::textUtils::addFinalNumber(getTargetPropertyName(), selector);
setPropertyImmediate(sliderName, newValue);
sendAction("change_property", targetPropertyName, getProperty(sliderName));
}
}
// for VST wrapper.
void MLPluginProcessor::setParameterAsLinearProportion (int index, float newValue)
{
if (index < 0) return;
MLPublishedParamPtr p = mEngine.getParamPtr(index);
if(p)
{
p->setValueAsLinearProportion(newValue);
mEngine.setPublishedParam(index, p->getValue());
mHasParametersSet = true;
// set MLModel Parameter
MLSymbol paramName = getParameterAlias(index);
float realVal = mEngine.getParamByIndex(index);
setPropertyImmediate(paramName, realVal);
}
}
void MLPluginProcessor::setStateFromXML(const XmlElement& xmlState, bool setViewAttributes)
{
if (!(xmlState.hasTagName (JucePlugin_Name))) return;
if (!(mEngine.getCompileStatus() == MLProc::OK)) return; // TODO revisit need to compile first
// getCallbackLock() is in juce_AudioProcessor
// process lock is a quick fix. it is here to prevent doParams() from getting called in
// process() methods and thereby setting mParamsChanged to false before the real changes take place.
// A better alternative would be a lock-free queue of parameter changes.
const ScopedLock sl (getCallbackLock());
// only the differences between default parameters and the program state are saved in a program,
// so the first step is to set the default parameters.
setDefaultParameters();
// get program version of saved state
unsigned blobVersion = xmlState.getIntAttribute ("pluginVersion");
unsigned pluginVersion = JucePlugin_VersionCode;
if (blobVersion > pluginVersion)
{
// TODO show error to user
MLError() << "MLPluginProcessor::setStateFromXML: saved program version is newer than plugin version!\n";
return;
}
// try to load scale if a scale attribute exists
// TODO auto save all state including this
const String scaleDir = xmlState.getStringAttribute ("scaleDir"); // look for old-style dir attribute
const String scaleName = xmlState.getStringAttribute ("scaleName");
String fullName;
if(scaleName != String::empty)
{
fullName = scaleName;
if(scaleDir != String::empty)
{
fullName = scaleDir + String("/") + fullName + ".scl";
}
}
else
{
fullName = "12-equal";
}
std::string fullScaleName(fullName.toUTF8());
setProperty("key_scale", fullScaleName);
bool loaded = false;
// look for scale under full name with path
if(fullScaleName != std::string())
{
const MLFilePtr f = mScaleFiles->getFileByName(fullScaleName);
if(f != MLFilePtr())
{
loadScale(f->mFile);
loaded = true;
}
}
if(!loaded)
{
loadDefaultScale();
}
// get preset name saved in blob. when saving from AU host, name will also be set from RestoreState().
const String presetName = xmlState.getStringAttribute ("presetName");
setProperty("preset", std::string(presetName.toUTF8()));
/*
debug() << "MLPluginProcessor: setStateFromXML: loading program " << presetName << ", version " << std::hex << blobVersion << std::dec << "\n";
MemoryOutputStream myStream;
xmlState->writeToStream (myStream, "");
debug() << myStream.toString();
*/
/*
setCurrentPresetName(presetName.toUTF8());
setCurrentPresetDir(presetDir.toUTF8());
*/
// get plugin-specific translation table for updating older versions of data
std::map<MLSymbol, MLSymbol> translationTable;
// TODO move this into Aalto!
// make translation tables based on program version.
//
if (blobVersion <= 0x00010120)
{
// translate seq parameters
for(unsigned n=0; n<16; ++n)
{
std::stringstream pName;
std::stringstream pName2;
pName << "seq_value" << n;
pName2 << "seq_pulse" << n;
MLSymbol oldSym(pName.str());
MLSymbol newSym = MLSymbol("seq_value#").withFinalNumber(n);
MLSymbol oldSym2(pName2.str());
MLSymbol newSym2 = MLSymbol("seq_pulse#").withFinalNumber(n);
translationTable[oldSym] = newSym;
translationTable[oldSym2] = newSym2;
}
}
if (blobVersion <= 0x00010200)
{
MLSymbol oldSym = MLSymbol("seq_value");
MLSymbol newSym = MLSymbol("seq_value").withFinalNumber(0);
MLSymbol oldSym2 = MLSymbol("seq_pulse");
MLSymbol newSym2 = MLSymbol("seq_pulse").withFinalNumber(0);
translationTable[oldSym] = newSym;
translationTable[oldSym2] = newSym2;
// translate seq parameters
for(unsigned n=1; n<16; ++n)
{
oldSym = MLSymbol("seq_value#").withFinalNumber(n);
newSym = MLSymbol("seq_value").withFinalNumber(n);
oldSym2 = MLSymbol("seq_pulse#").withFinalNumber(n);
newSym2 = MLSymbol("seq_pulse").withFinalNumber(n);
translationTable[oldSym] = newSym;
translationTable[oldSym2] = newSym2;
}
}
// get params from xml
const unsigned numAttrs = xmlState.getNumAttributes();
String patcherInputStr ("patcher_input_");
for(unsigned i=0; i<numAttrs; ++i)
{
// get name / value pair.
const String& attrName = xmlState.getAttributeName(i);
const MLParamValue paramVal = xmlState.getDoubleAttribute(attrName);
// if not a patcher input setting,
if (!attrName.contains(patcherInputStr))
{
// see if we have this named parameter in our engine.
MLSymbol paramSym = XMLAttrToSymbol(attrName);
const int pIdx = getParameterIndex(paramSym);
if (pIdx >= 0)
{
// debug() << "setStateFromXML: <" << paramSym << " = " << paramVal << ">\n";
setPropertyImmediate(paramSym, paramVal);
}
else // try finding a match through translation table.
{
//debug() << "Looking for parameter " << paramSym << " in table...\n";
std::map<MLSymbol, MLSymbol>::iterator it;
it = translationTable.find(paramSym);
if (it != translationTable.end())
{
const MLSymbol newSym = translationTable[paramSym];
const int pNewIdx = getParameterIndex(newSym);
if (pNewIdx >= 0)
{
//debug() << "translated parameter to " << newSym << " .\n";
setPropertyImmediate(newSym, paramVal);
}
else
{
MLError() << "MLPluginProcessor::setStateFromXML: no such parameter! \n";
}
}
else
{
// fail silently on unfound params, because we have deprecated some but they may still
// be around in old presets.
//debug() << "MLPluginProcessor::setStateFromXML: parameter " << paramSym << " not found!\n";
}
}
}
}
// get editor state from XML
if(setViewAttributes)
{
int x = xmlState.getIntAttribute("editor_x");
int y = xmlState.getIntAttribute("editor_y");
int width = xmlState.getIntAttribute("editor_width");
int height = xmlState.getIntAttribute("editor_height");
mEditorRect = MLRect(x, y, width, height);
mEditorNumbersOn = xmlState.getIntAttribute("editor_num", 1);
mEditorAnimationsOn = xmlState.getIntAttribute("editor_anim", 1);
}
}
void MLMenuButton::clicked ()
{
sendAction("show_menu", getTargetPropertyName());
setPropertyImmediate("value", 1);
}
