//==============================================================================
void JenSx1000AudioProcessor::getStateInformation (MemoryBlock& destData)
{
// You should use this method to store your parameters in the memory block.
// You could do that either as raw data, or use the XML or ValueTree classes
// as intermediaries to make it easy to save and load complex data.
Program currentProgram("Current Program");
currentProgram.vcoTune = vcoTuneParam->getValue();
currentProgram.vcoOctave = vcoOctaveParam->getValue();
currentProgram.vcoVibrato = vcoVibratoParam->getValue();
currentProgram.vcoWaveform = vcoWaveformParam->getValue();
currentProgram.vcoPulseWidth = vcoPulseWidthParam->getValue();
currentProgram.vcoPWM = vcoPWMParam->getValue();
currentProgram.vcoLevel = vcoLevelParam->getValue();
currentProgram.vcoGlide = vcoGlideParam->getValue();
currentProgram.lfoSpeed = lfoSpeedParam->getValue();
currentProgram.vcfFrequency = vcfFrequencyParam->getValue();
currentProgram.vcfResonance = vcfResonanceParam->getValue();
currentProgram.vcfLFO = vcfLFOParam->getValue();
currentProgram.vcfEnvLevel = vcfEnvLevelParam->getValue();
currentProgram.vcfAttack = vcfAttackParam->getValue();
currentProgram.vcfDecay = vcfDecayParam->getValue();
currentProgram.vcfSustain = vcfSustainParam->getValue();
currentProgram.vcfRelease = vcfReleaseParam->getValue();
currentProgram.noiseNoise = noiseNoiseParam->getValue();
currentProgram.noiseLevel = noiseLevelParam->getValue();
currentProgram.vcaOutputVolume = vcaOutputVolumeParam->getValue();
currentProgram.vcaAttack = vcaAttackParam->getValue();
currentProgram.vcaDecay = vcaDecayParam->getValue();
currentProgram.vcaSustain = vcaSustainParam->getValue();
currentProgram.vcaRelease = vcaReleaseParam->getValue();
copyXmlToBinary (currentProgram.getProgrameAsXmlElement(), destData);
}
//==============================================================================
void DemoJuceFilter::getStateInformation (MemoryBlock& destData)
{
XmlElement xmlState (T("faust"));
xmlState.setAttribute (T("pluginVersion"), 1);
xmlState.setAttribute (T("pluginName"), getName());
copyXmlToBinary (xmlState, destData);
}
void StocSynthAudioProcessor::getStateInformation (MemoryBlock& destData)
{
XmlElement xml ("STOCSETTINGS");
xml.setAttribute("toneAmp", toneAmp);
xml.setAttribute("a135", a135);
xml.setAttribute("a246", a246);
xml.setAttribute("a789", a789);
xml.setAttribute("sub", sub);
xml.setAttribute("var135", var135);
xml.setAttribute("var246", var246);
xml.setAttribute("var789", var789);
xml.setAttribute("pitch135", pitch135);
xml.setAttribute("pitch246", pitch246);
xml.setAttribute("pitch789", pitch789);
xml.setAttribute("cutoff", cutoff);
xml.setAttribute("res", res);
xml.setAttribute("ampA", ampA);
xml.setAttribute("ampD", ampD);
xml.setAttribute("ampS", ampS);
xml.setAttribute("ampR", ampR);
xml.setAttribute("gain", gain);
copyXmlToBinary (xml, destData);
}
//==============================================================================
void TheFunctionAudioProcessor::getStateInformation (MemoryBlock& destData)
{
// You should use this method to store your parameters in the memory block.
// You could do that either as raw data, or use the XML or ValueTree classes
// as intermediaries to make it easy to save and load complex data.
// Create an outer XML element..
XmlElement xml ("MYPLUGINSETTINGS");
// add some attributes to it..
// xml.setAttribute ("uiWidth", lastUIWidth);
// xml.setAttribute ("uiHeight", lastUIHeight);
//xml.setAttribute ("gain", gain);
// xml.setAttribute ("delay", delay);
xml.setAttribute ("gain", gain);
xml.setAttribute ("gainL", gainL);
xml.setAttribute ("gainR", gainR);
xml.setAttribute ("panL", panL);
xml.setAttribute ("panR", panR);
xml.setAttribute ("phaseL", phaseL);
xml.setAttribute ("phaseR", phaseR);
// then use this helper function to stuff it into the binary blob and return it..
copyXmlToBinary (xml, destData);
}
//==============================================================================
void JuceDemoPluginAudioProcessor::getStateInformation(MemoryBlock& destData)
{
// You should use this method to store your parameters in the memory block.
// Here's an example of how you can use XML to make it easy and more robust:
// Create an outer XML element..
XmlElement xml("MYPLUGINSETTINGS");
// add some attributes to it..
xml.setAttribute("uiWidth", lastUIWidth);
xml.setAttribute("uiHeight", lastUIHeight);
xml.setAttribute("wetGain", wetGain);
xml.setAttribute("delayAmount", delayAmount);
xml.setAttribute("delayTime", delayTime);
xml.setAttribute("delayFeedback", delayFeedbackAmount);
xml.setAttribute("pan", pan);
xml.setAttribute("dryOn", dryOn);
xml.setAttribute("midSide", midSide);
xml.setAttribute("roomSize", roomSize);
xml.setAttribute("roomDamp", roomDamp);
xml.setAttribute("hpfFreq", hpfFreq);
xml.setAttribute("hpfQ", hpfQ);
xml.setAttribute("saturation", saturationAmount);
xml.setAttribute("midOn", midOn);
xml.setAttribute("lpfFreq", lpfFreqValue);
xml.setAttribute("lpfQ", lpfQValue);
// then use this helper function to stuff it into the binary blob and return it..
copyXmlToBinary(xml, destData);
}
//==============================================================================
void SignalProcessorAudioProcessor::getStateInformation (MemoryBlock& destData)
{
// Create an outer XML element..
XmlElement xml ("MYPLUGINSETTINGS");
// add some attributes to it..
xml.setAttribute ("averagingBufferSize", averagingBufferSize);
xml.setAttribute ("fftAveragingWindow", fftAveragingWindow);
xml.setAttribute ("inputSensitivity", inputSensitivity);
xml.setAttribute ("sendTimeInfo", sendTimeInfo);
xml.setAttribute ("sendSignalLevel", sendSignalLevel);
xml.setAttribute ("sendImpulse", sendImpulse);
xml.setAttribute ("sendFFT", sendFFT);
xml.setAttribute ("channel", channel);
xml.setAttribute ("monoStereo", monoStereo);
xml.setAttribute ("logarithmicFFT", logarithmicFFT);
xml.setAttribute ("averageEnergyBufferSize", averageEnergyBufferSize);
xml.setAttribute ("sendOSC", sendOSC);
xml.setAttribute ("sendBinaryUDP", sendBinaryUDP);
xml.setAttribute ("instantSigValGain", instantSigValGain);
xml.setAttribute ("instantSigValNbOfSamplesSkipped", instantSigValNbOfSamplesSkipped);
// then use this helper function to stuff it into the binary blob and return it..
copyXmlToBinary (xml, destData);
}
//==============================================================================
void Ambix_converterAudioProcessor::getStateInformation (MemoryBlock& destData)
{
// You should use this method to store your parameters in the memory block.
// You could do that either as raw data, or use the XML or ValueTree classes
// as intermediaries to make it easy to save and load complex data.
// Create an outer XML element..
XmlElement xml ("MYPLUGINSETTINGS");
// add some attributes to it..
xml.setAttribute ("box_presets", box_presets_text);
xml.setAttribute("in_seq_param", in_seq_param);
xml.setAttribute("out_seq_param", out_seq_param);
xml.setAttribute("in_norm_param", in_norm_param);
xml.setAttribute("out_norm_param", out_norm_param);
xml.setAttribute("flip_cs_phase", flip_cs_phase);
xml.setAttribute("flip_param", flip_param);
xml.setAttribute("flop_param", flop_param);
xml.setAttribute("flap_param", flap_param);
xml.setAttribute("in_2d_param", in_2d);
xml.setAttribute("out_2d_param", out_2d);
// then use this helper function to stuff it into the binary blob and return it..
copyXmlToBinary (xml, destData);
}
//==============================================================================
void DemoJuceFilter::getStateInformation (MemoryBlock& destData)
{
// you can store your parameters as binary data if you want to or if you've got
// a load of binary to put in there, but if you're not doing anything too heavy,
// XML is a much cleaner way of doing it - here's an example of how to store your
// params as XML..
// create an outer XML element..
XmlElement xmlState (T("XSynthPatch"));
// add some attributes to it..
xmlState.setAttribute (T("pluginVersion"), 1);
xmlState.setAttribute (T("gainLevel"), gain);
xmlState.setAttribute (T("uiWidth"), lastUIWidth);
xmlState.setAttribute (T("uiHeight"), lastUIHeight);
// you could also add as many child elements as you need to here..
for (int i=0; i<getNumParameters(); i++)
{
xmlState.setAttribute (getParameterXMLName(i), getParameter(i));
DBG(String("Saved parameter ") + getParameterXMLName(i) + String(" as ") + String(getParameter(i)));
}
// then use this helper function to stuff it into the binary blob and return it..
copyXmlToBinary (xmlState, destData);
}
void MLPluginProcessor::getStateInformation (MemoryBlock& destData)
{
// create an outer XML element.
ScopedPointer<XmlElement> xmlProgram (new XmlElement(JucePlugin_Name));
getStateAsXML(*xmlProgram);
copyXmlToBinary (*xmlProgram, destData);
}
//==============================================================================
void UGenPlugin::getStateInformation (MemoryBlock& destData)
{
// you can store your parameters as binary data if you want to or if you've got
// a load of binary to put in there, but if you're not doing anything too heavy,
// XML is a much cleaner way of doing it - here's an example of how to store your
// params as XML..
// create an outer XML element..
const String pluginName = UGenUtility::stringToSafeName(JucePlugin_Name);
XmlElement xmlState (pluginName);
// add some attributes to it..
xmlState.setAttribute ("pluginVersion", 1);
for(int index = 0; index < UGenInterface::Parameters::Count; index++)
{
String parameterName = UGenUtility::stringToSafeName(String(UGenInterface::Parameters::Names[index]));
parameterName += "_";
parameterName += String(index); // try to ensure the name is unique, not foolproof
xmlState.setAttribute (parameterName, parameters[index]);
}
xmlState.setAttribute ("menuItem", menuItem);
xmlState.setAttribute ("menu2Item", menu2Item);
const String relative = irFile.getRelativePathFrom(File::getSpecialLocation(File::userHomeDirectory));
xmlState.setAttribute("irFile", relative);
// xmlState.setAttribute("lastPath", lastPath);
xmlState.setAttribute("selectedTab", selectedTab);
const Buffer& ampEnvLevels = ampEnv.getLevels();
const Buffer& ampEnvTimes = ampEnv.getTimes();
xmlState.setAttribute("ampEnvNumLevels", ampEnvLevels.size());
for (int i = 0; i < ampEnvLevels.size(); i++)
xmlState.setAttribute(String("ampEnvLevel")+String(i), (double)ampEnvLevels.getSampleUnchecked(i));
xmlState.setAttribute("ampEnvNumTimes", ampEnvTimes.size());
for (int i = 0; i < ampEnvTimes.size(); i++)
xmlState.setAttribute(String("ampEnvTime")+String(i), (double)ampEnvTimes.getSampleUnchecked(i));
const Buffer& filterEnvLevels = filterEnv.getLevels();
const Buffer& filterEnvTimes = filterEnv.getTimes();
xmlState.setAttribute("filterEnvNumLevels", filterEnvLevels.size());
for (int i = 0; i < filterEnvLevels.size(); i++)
xmlState.setAttribute(String("filterEnvLevel")+String(i), (double)filterEnvLevels.getSampleUnchecked(i));
xmlState.setAttribute("filterEnvNumTimes", filterEnvTimes.size());
for (int i = 0; i < filterEnvTimes.size(); i++)
xmlState.setAttribute(String("filterEnvTime")+String(i), (double)filterEnvTimes.getSampleUnchecked(i));
// then use this helper function to stuff it into the binary blob and return it..
copyXmlToBinary (xmlState, destData);
//DBG(xmlState.getAllSubText());
}
//==============================================================================
void BeatboxVoxAudioProcessor::getStateInformation(MemoryBlock& destData)
{
// You should use this method to store your parameters in the memory block.
// You could do that either as raw data, or use the XML or ValueTree classes
// as intermediaries to make it easy to save and load complex data.
std::unique_ptr<XmlElement> xml(processorState.state.createXml());
copyXmlToBinary(*xml, destData);
}
//==============================================================================
void SuperSpreadAudioProcessor::getStateInformation (MemoryBlock& destData)
{
XmlElement xml("STATE");
for (int i=0; i<getNumParameters(); ++i)
xml.setAttribute(getParameterName(i), getParameter(i));
copyXmlToBinary(xml, destData);
}
//==============================================================================
void Processor::getStateInformation (MemoryBlock& destData)
{
const juce::File irDirectory = _settings.getImpulseResponseDirectory();
juce::ScopedPointer<juce::XmlElement> element(SaveState(irDirectory, *this));
if (element)
{
copyXmlToBinary(*element, destData);
}
}
void Plugin::getStateInformation (MemoryBlock& destData)
{
// save current program
program_bank->saveProgramState(current_program);
// output program_bank to host
XmlElement* bankXml = program_bank->createBankXml();
copyXmlToBinary(*bankXml, destData);
editor_program_update_pending = true;
}
//==============================================================================
void LuftikusAudioProcessor::getStateInformation (MemoryBlock& destData)
{
XmlElement xml("LUFTIKUSDATA");
for (int i=0; i<getNumParameters(); ++i)
xml.setAttribute(getParameterName(i).replace(" ", "_", false).replace(".", "-", false), getParameter(i));
xml.setAttribute("tooltips", showTooltips ? 1 : 0);
copyXmlToBinary(xml, destData);
}
//==============================================================================
void AudioProcessorValueTreeStateDemoAudioProcessor::getStateInformation (MemoryBlock& destData)
{
// You should use this method to store your parameters in the memory block.
// You could do that either as raw data, or use the XML or ValueTree classes
// as intermediaries to make it easy to save and load complex data.
DBG("Store XML");
ScopedPointer<XmlElement> xml(parameters.state.createXml());
copyXmlToBinary (*xml, destData);
}
//=============================================================================
void KawaMidSideAudioProcessor::getStateInformation (MemoryBlock& destData)
{
//=========================================================================
XmlElement xml( "kawaMidSide_Parameter" );
//=========================================================================
xml.setAttribute( "isMidMode", isMidMode() );
xml.setAttribute( "isDoubleLevelMode", isDoubleLevelMode() );
//=========================================================================
copyXmlToBinary (xml, destData);
//=========================================================================
}
void Plugin::getCurrentProgramStateInformation(MemoryBlock& destData)
{
//save current settings
program_bank->saveProgramState(current_program);
saveProgramTo(current_program);
//output program to host
XmlElement* program = program_bank->createProgramXml(current_program);
copyXmlToBinary (*program, destData);
delete program;
}
//==============================================================================
void Tunefish4AudioProcessor::getStateInformation (MemoryBlock& destData)
{
XmlElement xml ("TF4SETTINGS");
for (eU32 i=0; i<TF_PARAM_COUNT; i++)
{
xml.setAttribute (TF_NAMES[i], tf->params[i]);
}
copyXmlToBinary (xml, destData);
}
//==============================================================================
void PitchedDelayAudioProcessor::getStateInformation (MemoryBlock& destData)
{
XmlElement xml("PitchedDelay");
for (int i=0; i<getNumParameters(); ++i)
xml.setAttribute(getParameterName(i), getParameter(i));
xml.setAttribute("currenttab", jmax(0, currentTab));
xml.setAttribute("showtooltips", showTooltips ? 1 : 0);
xml.setAttribute("extended", "1");
copyXmlToBinary(xml, destData);
}
void PluginAudioProcessor::getStateInformation (MemoryBlock& destData)
{
// You should use this method to store your parameters in the memory block.
// You could do that either as raw data, or use the XML or ValueTree classes
// as intermediaries to make it easy to save and load complex data.
XmlElement xml ("SyzygrydSettings");
xml.setAttribute ("panelIndex", panelIndex);
xml.setAttribute ("noteLength", sequencer->getNoteLength());
xml.setAttribute ("swingTicks", sequencer->getSwingTicks());
String state = SharedState::getInstance()->getStringPanelState (panelIndex);
xml.setAttribute ("panelState", state);
copyXmlToBinary (xml, destData);
}
//==============================================================================
void SamplerProcessor::getStateInformation (MemoryBlock& destData)
{
// You should use this method to store your parameters in the memory block.
// Here's an example of how you can use XML to make it easy and more robust:
// Create an outer XML element..
XmlElement xml ("MYPLUGINSETTINGS");
// add some attributes to it..
xml.setAttribute ("uiWidth", lastUIWidth);
xml.setAttribute ("uiHeight", lastUIHeight);
// then use this helper function to stuff it into the binary blob and return it..
copyXmlToBinary (xml, destData);
}
//==============================================================================
void FilterGuiDemoAudioProcessor::getStateInformation (MemoryBlock& destData)
{
// You should use this method to store your parameters in the memory block.
// You could do that either as raw data, or use the XML or ValueTree classes
// as intermediaries to make it easy to save and load complex data.
// Create an outer XML element..
XmlElement xml ("MYPLUGINSETTINGS");
// Store the values of all our parameters, using their param ID as the XML attribute
for (int i = 0; i < getNumParameters(); ++i)
if (AudioProcessorParameterWithID* p = dynamic_cast<AudioProcessorParameterWithID*> (getParameters().getUnchecked(i)))
xml.setAttribute (p->paramID, p->getValue());
// then use this helper function to stuff it into the binary blob and return it..
copyXmlToBinary (xml, destData);
}
//==============================================================================
void Mcfx_convolverAudioProcessor::getStateInformation (MemoryBlock& destData)
{
// You should use this method to store your parameters in the memory block.
// You could do that either as raw data, or use the XML or ValueTree classes
// as intermediaries to make it easy to save and load complex data.
// Create an outer XML element..
XmlElement xml ("MYPLUGINSETTINGS");
// add some attributes to it..
xml.setAttribute ("activePreset", activePreset);
xml.setAttribute ("presetDir", presetDir.getFullPathName());
xml.setAttribute("ConvBufferSize", (int)_ConvBufferSize);
// then use this helper function to stuff it into the binary blob and return it..
copyXmlToBinary (xml, destData);
}
//==============================================================================
void Ambix_directional_loudnessAudioProcessor::getStateInformation (MemoryBlock& destData)
{
// You should use this method to store your parameters in the memory block.
// You could do that either as raw data, or use the XML or ValueTree classes
// as intermediaries to make it easy to save and load complex data.
// Create an outer XML element..
XmlElement xml ("MYPLUGINSETTINGS");
// add some attributes to it..
for (int i=0; i < getNumParameters(); i++)
{
xml.setAttribute (String(i), getParameter(i));
}
// then use this helper function to stuff it into the binary blob and return it..
copyXmlToBinary (xml, destData);
}
//==============================================================================
void JuceDemoPluginAudioProcessor::getStateInformation (MemoryBlock& destData)
{
// You should use this method to store your parameters in the memory block.
// Here's an example of how you can use XML to make it easy and more robust:
// Create an outer XML element..
XmlElement xml ("MYPLUGINSETTINGS");
// add some attributes to it..
xml.setAttribute ("uiWidth", lastUIWidth);
xml.setAttribute ("uiHeight", lastUIHeight);
xml.setAttribute ("gain", offset->getValue());
xml.setAttribute ("delay", springConstant->getValue());
xml.setAttribute ("velocity", velocityFactor->getValue());
// then use this helper function to stuff it into the binary blob and return it..
copyXmlToBinary (xml, destData);
}
//==============================================================================
void DRowAudioFilter::getStateInformation (MemoryBlock& destData)
{
// you can store your parameters as binary data if you want to or if you've got
// a load of binary to put in there, but if you're not doing anything too heavy,
// XML is a much cleaner way of doing it - here's an example of how to store your
// params as XML..
// create an outer XML element..
XmlElement xmlState ("MYPLUGINSETTINGS");
// add some attributes to it..
xmlState.setAttribute ("pluginVersion", 1);
for(int i = 0; i < noParams; i++) {
params[i].writeXml(xmlState);
}
// then use this helper function to stuff it into the binary blob and return it..
copyXmlToBinary (xmlState, destData);
}
void HoaToolsAudioProcessor::getStateInformation(MemoryBlock& destData)
{
char name[256];
XmlElement xml("HoaToolsSettings");
xml.setAttribute("NumberOfSources", (int)getNumberOfSources());
for (int i = 0; i < getNumberOfSources(); i++)
{
sprintf(name, "Abscissa%i", i);
xml.setAttribute(name, (double)m_sources->sourceGetAbscissa(i));
sprintf(name, "Ordinate%i", i);
xml.setAttribute(name, (double)m_sources->sourceGetOrdinate(i));
}
copyXmlToBinary(xml, destData);
}
//==============================================================================
void JuceDemoPluginAudioProcessor::getStateInformation (MemoryBlock& destData)
{
// You should use this method to store your parameters in the memory block.
// Here's an example of how you can use XML to make it easy and more robust:
// Create an outer XML element..
XmlElement xml ("MYPLUGINSETTINGS");
// add some attributes to it..
xml.setAttribute ("uiWidth", lastUIWidth);
xml.setAttribute ("uiHeight", lastUIHeight);
// Store the values of all our parameters, using their param ID as the XML attribute
for (int i = 0; i < getNumParameters(); ++i)
if (AudioProcessorParameterWithID* p = dynamic_cast<AudioProcessorParameterWithID*> (getParameters().getUnchecked(i)))
xml.setAttribute (p->paramID, p->getValue());
// then use this helper function to stuff it into the binary blob and return it..
copyXmlToBinary (xml, destData);
}
//==============================================================================
void DRowAudioFilter::getStateInformation (MemoryBlock& destData)
{
// you can store your parameters as binary data if you want to or if you've got
// a load of binary to put in there, but if you're not doing anything too heavy,
// XML is a much cleaner way of doing it - here's an example of how to store your
// params as XML..
// create an outer XML element..
XmlElement xmlState (T("MYPLUGINSETTINGS"));
// add some attributes to it..
xmlState.setAttribute (T("pluginVersion"), 1);
// xmlState.setAttribute (T("gainLevel"), gain);
// you could also add as many child elements as you need to here..
// then use this helper function to stuff it into the binary blob and return it..
copyXmlToBinary (xmlState, destData);
}
