const int CtrlrPanel::cleanBogusPropertiesFromChild(ValueTree &treeToClean)
{
int removedProperties = 0;
for (int j=0; j<treeToClean.getNumProperties(); j++)
{
/*if (Ids::ctrlrIdContainer->getVid (treeToClean.getPropertyName(j)) < 0)
{
removedProperties++;
treeToClean.removeProperty(treeToClean.getPropertyName(j), 0);
}
*/
}
if (treeToClean.getNumChildren() > 0)
{
for (int i=0; i<treeToClean.getNumChildren(); i++)
{
ValueTree child = treeToClean.getChild(i);
const int r = cleanBogusPropertiesFromChild (child);
removedProperties = removedProperties + r;
}
}
return (removedProperties);
}
bool ModulatorSamplerSoundPool::loadMonolithicData(const ValueTree &sampleMap, const Array<File>& monolithicFiles, OwnedArray<ModulatorSamplerSound> &sounds)
{
jassert(!mc->getMainSynthChain()->areVoicesActive());
clearUnreferencedMonoliths();
loadedMonoliths.add(new MonolithInfoToUse(monolithicFiles));
MonolithInfoToUse* hmaf = loadedMonoliths.getLast();
try
{
hmaf->fillMetadataInfo(sampleMap);
}
catch (StreamingSamplerSound::LoadingError l)
{
String x;
x << "Error at loading sample " << l.fileName << ": " << l.errorDescription;
mc->getDebugLogger().logMessage(x);
#if USE_FRONTEND
mc->sendOverlayMessage(DeactiveOverlay::State::CustomErrorMessage, x);
#else
debugError(mc->getMainSynthChain(), x);
#endif
}
for (int i = 0; i < sampleMap.getNumChildren(); i++)
{
ValueTree sample = sampleMap.getChild(i);
if (sample.getNumChildren() == 0)
{
String fileName = sample.getProperty("FileName").toString().fromFirstOccurrenceOf("{PROJECT_FOLDER}", false, false);
StreamingSamplerSound* sound = new StreamingSamplerSound(hmaf, 0, i);
pool.add(sound);
sounds.add(new ModulatorSamplerSound(mc, sound, i));
}
else
{
StreamingSamplerSoundArray multiMicArray;
for (int j = 0; j < sample.getNumChildren(); j++)
{
StreamingSamplerSound* sound = new StreamingSamplerSound(hmaf, j, i);
pool.add(sound);
multiMicArray.add(sound);
}
sounds.add(new ModulatorSamplerSound(mc, multiMicArray, i));
}
}
sendChangeMessage();
return true;
}
void StateWriter::setState (const void* data, int sizeInBytes)
{
DBG("StateWriter::setState(): Loading state.")
ValueTree settingsTree = ValueTree::readFromData (data, sizeInBytes);
ValueTree libTree = settingsTree.getChildWithName ("library");
library->setThreshold (libTree.getProperty ("threshold"));
library->setReleaseTicks (libTree.getProperty ("release"));
library->setVelocityScale (libTree.getProperty ("velocity"));
ValueTree patternsTree = settingsTree.getChildWithName ("patterns");
for (int i = 0; i < patternsTree.getNumChildren(); i++) {
Pattern* pattern = library->getPattern (i);
ValueTree patternTree = patternsTree.getChild (i);
ValueTree instrumentsTree = patternTree.getChildWithName ("instruments");
for (int j = 0; j < instrumentsTree.getNumChildren(); j++) {
ValueTree instrumentTree = instrumentsTree.getChild (j);
Instrument* instrument = pattern->getInstrumentAt (j);
instrument->setIndex (instrumentTree.getProperty ("index"));
instrument->setName (instrumentTree.getProperty ("name"));
instrument->setNoteNumber (instrumentTree.getProperty ("noteNumber"));
}
}
ValueTree seqTree = settingsTree.getChildWithName ("sequencer");
sequencer->setSequencerNum (seqTree.getProperty("sequencerNum"));
}
static bool isGroupSorted (const ValueTree& state, bool keepGroupsAtStart)
{
if (state.getNumChildren() == 0)
return false;
if (state.getNumChildren() == 1)
return true;
ValueTree stateCopy (state.createCopy());
sortGroup (stateCopy, keepGroupsAtStart, nullptr);
return stateCopy.isEquivalentTo (state);
}
void ObjController::removeAudioConnection(AudioOutConnector* aocComp,
bool undoable,
ObjectsHolder* holder)
{
if(undoable)
{
owner.getUndoManager().perform(new RemoveAudioConnectionAction(holder, aocComp, this));
}
else
{
sObjects.deselect(aocComp);
sObjects.changed(true);
ValueTree sources = aocComp->getAudioObject()->getData().getChildWithName(Ids::sources);
ValueTree source;
for (int i = 0; i < sources.getNumChildren(); ++i)
{
String val = sources.getChild(i)[Ids::value];
// DBG(aocComp->getSourceObject()->getData()[Ids::identifier].toString());
if(val.contains(aocComp->getSourceObject()->getData()[Ids::identifier].toString()))
{
source = sources.getChild(i);
break;
}
}
sources.removeChild(source, nullptr);
audioConnections.removeObject(aocComp);
}
}
void DrawablePath::ValueTreeWrapper::writeTo (RelativePointPath& relativePath) const
{
relativePath.usesNonZeroWinding = usesNonZeroWinding();
RelativePoint points[3];
const ValueTree pathTree (state.getChildWithName (path));
const int num = pathTree.getNumChildren();
for (int i = 0; i < num; ++i)
{
const Element e (pathTree.getChild(i));
const int numCps = e.getNumControlPoints();
for (int j = 0; j < numCps; ++j)
points[j] = e.getControlPoint (j);
RelativePointPath::ElementBase* newElement = 0;
const Identifier t (e.getType());
if (t == Element::startSubPathElement) newElement = new RelativePointPath::StartSubPath (points[0]);
else if (t == Element::closeSubPathElement) newElement = new RelativePointPath::CloseSubPath();
else if (t == Element::lineToElement) newElement = new RelativePointPath::LineTo (points[0]);
else if (t == Element::quadraticToElement) newElement = new RelativePointPath::QuadraticTo (points[0], points[1]);
else if (t == Element::cubicToElement) newElement = new RelativePointPath::CubicTo (points[0], points[1], points[2]);
else jassertfalse;
relativePath.addElement (newElement);
}
}
void CtrlrMIDILibrary::attachStandardTransactions()
{
ScopedPointer <XmlElement> root(nullptr);
ValueTree builtInTransactions;
if (File (owner.getProperty(Ids::midiLibraryTransactionsFile)).existsAsFile())
{
root = XmlDocument::parse (File(owner.getProperty(Ids::midiLibraryTransactionsFile)));
}
else
{
root = XmlDocument::parse (String::createStringFromData (BinaryData::CtrlrMIDITransactions_xml, BinaryData::CtrlrMIDITransactions_xmlSize));
}
if (root)
{
builtInTransactions = ValueTree::fromXml(*root);
if (getTransactions().isValid())
{
for (int i=0; i<builtInTransactions.getNumChildren(); i++)
{
getTransactions().addChild (builtInTransactions.getChild(i).createCopy(), -1, nullptr);
}
}
}
}
ValueTree CtrlrMIDILibrary::scanChildrenForMenuIndex(ValueTree item, int itemIndexToFind, int ¤tIndex)
{
_DBG("CtrlrMIDILibrary::scanChildrenForMenuIndex");
if (isContainer (item))
{
_DBG("\tcontainer ["+item.getType().toString()+"]");
ValueTree child;
for (int topLevelIndex=0; topLevelIndex<item.getNumChildren(); topLevelIndex++)
{
child = scanChildrenForMenuIndex (item.getChild(topLevelIndex), itemIndexToFind, currentIndex);
if (child.isValid())
{
_DBG("\t\tvalid child found ["+child.getType().toString()+"] parent:["+child.getParent().getType().toString()+"]");
return (child);
}
currentIndex++;
}
}
if (itemIndexToFind == currentIndex)
{
_DBG("\t\titemIndexToFind == currentIndex ["+item.getType().toString()+"]");
return (item);
}
else
{
return (ValueTree());
}
}
bool MDLHelper::addOutputDSPVarIfNotExists(const MDLFile& mdlFile)
{
ValueTree mdlRoot = mdlFile.getMDLRoot();
bool outputDSPExists = false;
ValueTree fcb = mdlRoot.getOrCreateChildWithName(Objects::faustcodeblock, nullptr);
for (int i = 0; i < fcb.getNumChildren(); ++i)
{
ValueTree fc = fcb.getChild(i);
if (fc.hasProperty(Ids::value))
{
String fcStr = fc[Ids::value].toString();
if (fcStr.startsWith("outputDSP"))
{
outputDSPExists = true;
break;
}
}
}
if (!outputDSPExists)
{
ValueTree fc(Ids::faustcode);
fc.setProperty(Ids::value, "outputDSP=SAMlimiter:highpass(4,20.0);", nullptr);
fcb.addChild(fc, -1, nullptr);
return true;
}
return false;
}
void Project::updateOldStyleConfigList()
{
ValueTree deprecatedConfigsList (projectRoot.getChildWithName (ProjectExporter::configurations));
if (deprecatedConfigsList.isValid())
{
projectRoot.removeChild (deprecatedConfigsList, nullptr);
for (Project::ExporterIterator exporter (*this); exporter.next();)
{
if (exporter->getNumConfigurations() == 0)
{
ValueTree newConfigs (deprecatedConfigsList.createCopy());
if (! exporter->isXcode())
{
for (int j = newConfigs.getNumChildren(); --j >= 0;)
{
ValueTree config (newConfigs.getChild(j));
config.removeProperty (Ids::osxSDK, nullptr);
config.removeProperty (Ids::osxCompatibility, nullptr);
config.removeProperty (Ids::osxArchitecture, nullptr);
}
}
exporter->settings.addChild (newConfigs, 0, nullptr);
}
}
}
}
void CtrlrPanel::setProgram(ValueTree programTree, const bool sendSnapshotNow)
{
ValueTree program;
if (programTree.hasType(Ids::panelState))
{
program = programTree;
}
else
{
if (programTree.getChildWithName(Ids::panelState).isValid())
{
program = programTree.getChildWithName(Ids::panelState);
}
}
setProgramState (true);
if (program.isValid())
{
for (int i=0; i<program.getNumChildren(); i++)
{
if (program.getChild(i).hasType(Ids::value))
{
CtrlrModulator *m = getModulator (program.getChild(i).getProperty(Ids::name));
if (m)
{
m->setRestoreState (true);
m->getProcessor().setValueFromGUI (program.getChild(i).getProperty(Ids::value), true);
if (m->getComponent())
{
m->getComponent()->setComponentValue (program.getChild(i).getProperty(Ids::value), false);
}
m->getProcessor().handleUpdateNowIfNeeded();
m->setRestoreState (false);
}
}
}
if ((bool)getProperty (Ids::panelMidiSnapshotAfterProgramChange) == true)
{
snapshot.sendSnapshot();
}
if (luaPanelProgramChangedCbk && !luaPanelProgramChangedCbk.wasObjectDeleted())
{
if (luaPanelProgramChangedCbk->isValid())
{
getCtrlrLuaManager().getMethodManager().call (luaPanelProgramChangedCbk);
}
}
}
setProgramState (false);
if (sendSnapshotNow)
{
_DBG("CtrlrPanel::setProgram sendSnapshotNow");
sendSnapshot();
}
}
void UnityProjectBuilder::updateBuildDirectories()
{
if (buildDir.isEmpty())
return;
ValueTree exportsTree (project.getChildWithName (Ids::exportFormats));
if (! exportsTree.isValid())
return;
const int numExports = exportsTree.getNumChildren();
for (int i = 0; i < numExports; ++i)
{
ValueTree exporter (exportsTree.getChild (i));
if (exporter.hasProperty (Ids::targetFolderProp))
{
logOutput ("Updating exporter " + exporter.getType().toString());
const String oldTarget (exporter.getProperty (Ids::targetFolderProp).toString());
String newTarget (buildDir);
if (oldTarget.containsChar ('/'))
newTarget << oldTarget.fromLastOccurrenceOf ("/", true, false);
exporter.setProperty (Ids::targetFolderProp, newTarget, nullptr);
}
}
}
//==============================================================================
void AnalysisModel::turnOffAllPlotting(ValueTree analyserTree)
{
for (int i = 0;i < analyserTree.getNumChildren();i++)
{
analyserTree.getChild(i).setProperty(AnalysisProperties::plot, 0, nullptr);
}
}
static int indexOfNode (const ValueTree& parent, const ValueTree& child)
{
for (int i = parent.getNumChildren(); --i >= 0;)
if (parent.getChild (i) == child)
return i;
return -1;
}
void CtrlrManagerWindowManager::restoreState (const ValueTree &savedState)
{
restoreProperties (savedState, managerTree, nullptr);
for (int i=0; i<savedState.getNumChildren(); i++)
{
managerTree.addChild (savedState.getChild(i).createCopy(), -1, nullptr);
}
}
void Project::removeModule (const String& moduleID)
{
ValueTree modules (getModulesNode());
for (int i = 0; i < modules.getNumChildren(); ++i)
if (modules.getChild(i) [Ids::ID] == moduleID)
modules.removeChild (i, getUndoManagerFor (modules));
}
bool Project::isModuleEnabled (const String& moduleID) const
{
ValueTree modules (projectRoot.getChildWithName (Tags::modulesGroup));
for (int i = 0; i < modules.getNumChildren(); ++i)
if (modules.getChild(i) [Ids::ID] == moduleID)
return true;
return false;
}
ValueTree SAMCompiler::getJunctionLink(ValueTree linksTree, ValueTree jnctTree)
{
for (int i = 0; i < linksTree.getNumChildren(); ++i)
{
ValueTree link = linksTree.getChild(i);
if (link[Ids::startVertex] == jnctTree[Ids::identifier]
|| link[Ids::endVertex] == jnctTree[Ids::identifier])
return link;
}
return ValueTree::invalid;
}
const PopupMenu CtrlrSysExEditor::getVendorIdMenu()
{
PopupMenu m;
ValueTree vendorTree = owner->getOwner().getCtrlrIDManager().getVendorTree();
for (int i=0; i<vendorTree.getNumChildren(); i++)
{
m.addItem (1024+i, vendorTree.getChild(i).getProperty(Ids::name));
}
return (m);
}
void CtrlrManager::restoreState (const ValueTree &savedTree)
{
if (savedTree.isValid())
{
ctrlrManagerRestoring = true;
restoreProperties (savedTree, managerTree);
if (owner->getOverrides().isValid())
{
for (int i=0; i<owner->getOverrides().getNumProperties(); i++)
{
setProperty (owner->getOverrides().getPropertyName(i), owner->getOverrides().getPropertyAsValue(owner->getOverrides().getPropertyName(i), 0));
}
}
managerTree.removeAllChildren (0);
managerTree.addChild (ctrlrMidiDeviceManager.getManagerTree(), -1, 0);
managerTree.addChild (ctrlrWindowManager.getManagerTree(), -1, 0);
if (savedTree.getChildWithName(Ids::midiDeviceManager).isValid())
{
ctrlrMidiDeviceManager.restoreState (savedTree.getChildWithName(Ids::midiDeviceManager));
}
if (savedTree.getChildWithName(Ids::uiWindowManager).isValid())
{
ctrlrWindowManager.restoreState (savedTree.getChildWithName(Ids::uiWindowManager));
}
if (getInstanceMode() != InstanceMulti && savedTree.hasType (Ids::panelState))
{
restoreInstanceState (savedTree);
return;
}
for (int i=0; i<savedTree.getNumChildren(); i++)
{
if (savedTree.getChild(i).hasType (Ids::panel))
{
addPanel (savedTree.getChild(i));
}
}
if (ctrlrEditor)
{
restoreEditorState();
}
ctrlrManagerRestoring = false;
}
}
ApiCollection::ClassCollection::ClassCollection(const ValueTree &api) :
classApi(api),
name(api.getType().toString())
{
for (int i = 0; i < api.getNumChildren(); i++)
{
items.add(new MethodItem(api.getChild(i), name));
addAndMakeVisible(items.getLast());
}
}
void ScopeSync::applyConfiguration()
{
DBG("ScopeSync::applyConfiguration");
#ifdef __DLL_EFFECT__
scopeSyncAsync.toggleUpdateProcessing(false);
#endif
parameterController->toggleAsyncUpdates(false);
setGUIEnabled(false);
parameterController->endAllParameterChangeGestures();
systemError = String::empty;
systemErrorDetails = String::empty;
if (ScopeSyncApplication::inPluginContext())
parameterController->storeParameterValues();
parameterController->reset();
// Firstly create the BCMParameter entries for each of the Host Parameters
ValueTree parameterTree = configuration->getParameters();
for (int i = 0; i < parameterTree.getNumChildren(); i++)
parameterController->addParameter(parameterTree.getChild(i));
parameterController->setupHostParameters();
#ifndef __DLL_EFFECT__
pluginProcessor->updateHostDisplay();
#endif // __DLL_EFFECT__
#ifndef __DLL_EFFECT__
parameterController->restoreParameterValues();
#else
scopeSyncAsync.snapshot();
scopeSyncAsync.toggleUpdateProcessing(true);
#endif // __DLL_EFFECT__
UserSettings::getInstance()->updateConfigurationLibraryEntry(getConfigurationFile().getFullPathName(),
getConfigurationFile().getFileName(),
getConfigurationRoot());
setGUIReload(true);
if (configurationManagerWindow != nullptr)
{
configurationManagerWindow->refreshContent();
configurationManagerWindow->restoreWindowPosition();
}
parameterController->toggleAsyncUpdates(true);
}
ValueTree SAMCompiler::getWgForJunct(ValueTree waveguides, ValueTree j)
{
ValueTree wgs(Objects::waveguides);
for (int i = 0; i < waveguides.getNumChildren(); ++i)
{
ValueTree w = waveguides.getChild(i);
if (w[Ids::startVertex] == j[Ids::identifier]
|| w[Ids::endVertex] == j[Ids::identifier])
{
wgs.addChild(w.createCopy(), -1, nullptr);
}
}
return wgs;
}
void CtrlrComponent::restoreState (const ValueTree &savedState)
{
restoreStateInProgress = true;
restoreProperties (savedState, componentTree, nullptr);
for (int i=0; i<savedState.getNumChildren(); i++)
{
componentTree.addChild (savedState.getChild(i).createCopy(), -1, 0);
}
restoreStateInProgress = false;
resized();
}
StaticStreamViewport::ContentComponent::ContentComponent(ValueTree tree_,CriticalSection &lock_, WorkbenchClient* client_) :
tree(tree_),
lock(lock_)
{
int i;
setOpaque(true);
for (i = 0; i < tree_.getNumChildren(); ++i)
{
StaticStreamComponent* comp = new StaticStreamComponent(tree_.getChild(i), lock_, this, client_);
addAndMakeVisible(comp);
streamBoxes.add(comp);
}
}
void ComponentBuilder::updateChildComponents (Component& parent, const ValueTree& children)
{
using namespace ComponentBuilderHelpers;
const int numExistingChildComps = parent.getNumChildComponents();
Array <Component*> componentsInOrder;
componentsInOrder.ensureStorageAllocated (numExistingChildComps);
{
OwnedArray<Component> existingComponents;
existingComponents.ensureStorageAllocated (numExistingChildComps);
int i;
for (i = 0; i < numExistingChildComps; ++i)
existingComponents.add (parent.getChildComponent (i));
const int newNumChildren = children.getNumChildren();
for (i = 0; i < newNumChildren; ++i)
{
const ValueTree childState (children.getChild (i));
ComponentBuilder::TypeHandler* const type = getHandlerForState (childState);
jassert (type != nullptr);
if (type != nullptr)
{
Component* c = findComponentWithID (existingComponents, getStateId (childState));
if (c == nullptr)
c = createNewComponent (*type, childState, &parent);
componentsInOrder.add (c);
}
}
// (remaining unused items in existingComponents get deleted here as it goes out of scope)
}
// Make sure the z-order is correct..
if (componentsInOrder.size() > 0)
{
componentsInOrder.getLast()->toFront (false);
for (int i = componentsInOrder.size() - 1; --i >= 0;)
componentsInOrder.getUnchecked(i)->toBehind (componentsInOrder.getUnchecked (i + 1));
}
}
//==============================================================================
void UnityProjectBuilder::recurseGroup (ValueTree group, const File& sourceDir)
{
logOutput ("Recursing group \"" + group.getProperty (Ids::nameProp).toString() + "\"...");
const int numChildren = group.getNumChildren();
for (int i = 0; i < numChildren; ++i)
{
ValueTree child (group.getChild (i));
if (child.hasType (Ids::group))
recurseGroup (child, sourceDir);
else if (child.hasType (Ids::file))
parseFile (child, sourceDir);
}
}
void CtrlrPanelComponentProperties::changeListenerCallback (ChangeBroadcaster* source)
{
if (owner.getSelection() == nullptr)
return;
if (selectedItems != owner.getSelection()->getNumSelected() && owner.getSelection()->getNumSelected() > 1)
{
selectedItems = owner.getSelection()->getNumSelected();
msTree = ValueTree(Ids::modulator);
msTree.removeListener (this);
for (int i=0; i<owner.getSelection()->getNumSelected(); i++)
{
ValueTree modTree = owner.getSelection()->getSelectedItem(i)->getOwner().getModulatorTree();
copyProperties (modTree, msTree);
for (int i=0; i<modTree.getNumChildren(); i++)
{
if (!msTree.getChildWithName(modTree.getChild(i).getType()).isValid())
msTree.addChild (modTree.getChild(i).createCopy(), i, 0);
}
}
if (msTree.getChildWithName(Ids::component).isValid())
{
msTree.getChildWithName(Ids::component).setProperty (Ids::uiType, "uiMultipleSelection", 0);
}
msTree.addListener (this);
setTree (msTree);
}
if (owner.getSelection()->getNumSelected() == 0)
{
setTree (owner.getOwner().getPanelTree());
propertyPanel->restoreOpennessState(panelPropertyOpennessState);
}
if (owner.getSelection()->getNumSelected() == 1)
{
refreshTargetModulationPropertyList(owner.getSelection()->getSelectedItem(0)->getOwner().getModulatorTree());
refreshDynamicData();
setTree (owner.getSelection()->getSelectedItem(0)->getOwner().getModulatorTree());
propertyPanel->restoreOpennessState(modulatorPropertyOpennessState);
}
}
void CtrlrMIDILibrary::attachItemToPopupMenu(const ValueTree &itemToAttach, PopupMenu &m, int &itemOffset)
{
if (isContainer (itemToAttach))
{
PopupMenu subMenu;
for (int topLevelIndex=0; topLevelIndex<itemToAttach.getNumChildren(); topLevelIndex++)
{
attachItemToPopupMenu (itemToAttach.getChild(topLevelIndex), subMenu, itemOffset);
}
m.addSubMenu (itemToAttach.getProperty(Ids::name).toString(), subMenu, true);
}
else
{
m.addItem (itemOffset++, itemToAttach.getProperty(Ids::name).toString(), (!itemToAttach.hasType(Ids::midiLibraryData) && (bool)itemToAttach.getProperty(Ids::midiLibraryCanSendItem)), isCurrentProgram(itemToAttach));
}
}
void CtrlrLuaMethodEditor::removeGroup(ValueTree parentGroup)
{
if (parentGroup.getNumChildren() > 0)
{
if (SURE("Remove group: "+parentGroup.getProperty(Ids::name).toString()+" ?", this))
{
getMethodManager().removeGroup(parentGroup);
}
}
else
{
getMethodManager().removeGroup(parentGroup);
}
updateRootItem();
saveSettings(); // save settings
}
