//============================================================================== 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); }