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 CtrlrPanelCanvas::pasteGroupComponent(const ValueTree &groupTree, const int destinationX, const int destinationY) { if (groupTree.hasType ("groupTree")) { CtrlrComponent *parent = addNewComponent (groupTree.getChild(0), 0, true); if (destinationX >= 0 && destinationY >= 0) parent->setTopLeftPosition (destinationX, destinationY); else parent->setTopLeftPosition (parent->getX()+(parent->getWidth()/2), parent->getY()+(parent->getHeight()/2)); CtrlrGroup *group = dynamic_cast<CtrlrGroup*>(parent); CtrlrTabsComponent *tabs = dynamic_cast<CtrlrTabsComponent*>(parent); for (int i=0; i<groupTree.getChild(0).getNumChildren(); i++) { if (groupTree.getChild(0).getChild(i).hasType(Ids::modulator)) { CtrlrComponent *child = addNewComponent (groupTree.getChild(0).getChild(i), 0, true); if (group && child) { group->setOwned(child, true); } if (tabs && child) { tabs->setOwned(child, child->getProperty(Ids::componentTabId), 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")); }
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 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; } }
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); } } } }
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; }
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()); } }
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); } } } }
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); }
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 AnalysisModel::turnOffAllPlotting(ValueTree analyserTree) { for (int i = 0;i < analyserTree.getNumChildren();i++) { analyserTree.getChild(i).setProperty(AnalysisProperties::plot, 0, nullptr); } }
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 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 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); } }
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); }
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 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 CtrlrMIDILibrary::restoreState (const ValueTree &savedState) { if (savedState.isValid()) { getRoot().removeAllChildren(0); for (int i=0; i<savedState.getNumChildren(); i++) { getRoot().addChild (savedState.getChild(i).createCopy(), -1, 0); } getSnapshots() = getRoot().getChildWithName (Ids::midiLibrarySnapshots); getFirmware() = getRoot().getChildWithName (Ids::midiLibraryFirmware); getTransactions() = getRoot().getChildWithName (Ids::midiLibraryTransactions); restoreProperties(savedState, getRoot()); sendChangeMessage(); } }