void ObjController::addNewLinkIfPossible(ObjectsHolder* holder, ValueTree linkValues) { Array<ObjectComponent*> selectedObjects = ObjectsHelper::getSelectedComponents<ObjectComponent>(*this); if(selectedObjects.size() == 2) { ObjectComponent* oc1 = selectedObjects[0]; ObjectComponent* oc2 = selectedObjects[1]; jassert(oc1 && oc2); if (ObjectsHelper::canObjectsBeConnected(*oc1, *oc2, linkValues.getType()) && !checkIfLinkExitsts(linkValues)) { addLink(holder, linkValues, -1, true); } else { String msg = "Cannot connect "; msg << oc1->getData().getType().toString(); msg << " and "; msg << oc2->getData().getType().toString(); msg << " with "; msg << linkValues.getType().toString(); msg << "."; SAM_CONSOLE(msg, PostLevel::ERROR); } } else { SAM_CONSOLE("Please select 2 Objects", PostLevel::ERROR); } }
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()); } }
const bool CtrlrLuaMethodEditor::canBeRenamed(const ValueTree &item) const { if ( item.getType() == Ids::luaMethod && ((int)item.getProperty(Ids::luaMethodSource) == CtrlrLuaMethod::codeInProperty) ) { return (true); } if (item.getType() == Ids::luaMethodGroup) { return (true); } return (false); }
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); } } }
const AttributedString CtrlrLuaMethodEditor::getDisplayString(const ValueTree &item) const { AttributedString str; if (item.getType () == Ids::luaMethod) { Colour text; if ((bool)item.getProperty(Ids::luaMethodValid) == false) text = Colours::red; else text = Colours::black; str.append (item.getProperty(Ids::luaMethodName).toString()+"\n", Font(12.0f, Font::plain), text); if ((int)item.getProperty(Ids::luaMethodSource) == CtrlrLuaMethod::codeInFile) { str.append (File::descriptionOfSizeInBytes (File(item.getProperty(Ids::luaMethodSourcePath).toString()).getSize()), Font(10.0f, Font::italic), text.brighter(0.2f)); } else { str.append (File::descriptionOfSizeInBytes (item.getProperty(Ids::luaMethodCode).toString().length()), Font(10.0f, Font::italic), text.brighter(0.2f)); } str.setJustification (Justification::left); } if (item.getType() == Ids::luaMethodGroup) { str.append (item.getProperty(Ids::name), Font(14.0f, Font::plain), Colours::black); str.append (" ["+String(item.getNumChildren())+"]", Font(10.0f, Font::italic), Colours::darkgrey); str.setJustification (Justification::left); } if (item.getType() == Ids::luaManagerMethods) { str.append ("LUA", Font(14.0f, Font::bold), Colours::black); str.setJustification (Justification::left); } return (str); }
bool CtrlrMIDILibrary::transactionCanHandleType(const ValueTree &transactionState, const ValueTree transactionItem) { StringArray types = StringArray::fromTokens (transactionState.getProperty(Ids::transCap).toString(), ",; ", "\"\'"); for (int i=0; i<types.size(); i++) { if (types[i] == transactionItem.getType().toString()) return (true); } return (false); }
RemoteChannels::RemoteChannels(ValueTree user_store , ValueTree subscriptions) : configStore(user_store) { this->channelsLabel->setText(String(user_store.getType()) , juce::dontSendNotification) ; this->expandButton ->addListener(this) ; this->ignoreButton ->addListener(this) ; this->addButton ->setVisible(false) ; this->subscriptions = subscriptions ; this->isExpanded = false ; }
void StaticStreamViewport::StaticStreamComponent::valueTreePropertyChanged( ValueTree& treeWhosePropertyHasChanged, const Identifier& property ) { ScopedLock locker(lock); DBG("StaticStreamViewport::StaticStreamComponent::valueTreePropertyChanged " + treeWhosePropertyHasChanged.getType().toString() + " " + property.toString()); if (Identifiers::Name == property) { repaint(); return; } if (Identifiers::StreamID == property) { int64 streamID = tree[Identifiers::StreamID]; streamIdEditor.setText(String::toHexString(streamID)); return; } if (Identifiers::DestinationAddress == property) { int64 address64 = tree[Identifiers::DestinationAddress]; MACAddress address(Int64ToMACAddress(address64)); multicastAddressEditor.setText(address.toString()); return; } if (Identifiers::ChannelCount == property) { channelsCombo.setSelectedId(tree[Identifiers::ChannelCount], dontSendNotification); return; } if (Identifiers::Subtype == property) { int subtype = tree[Identifiers::Subtype]; clockReferenceButton.setToggleState(AVTP_SUBTYPE_CRS == subtype,dontSendNotification); setChannelsVisible(); return; } if (Identifiers::Active == property) { enableControls(treeWhosePropertyHasChanged.getProperty(property)); return; } if (Identifiers::AutoStart == property) { autoStartButton.setToggleState(treeWhosePropertyHasChanged[property],dontSendNotification); return; } }
bool Mixer::addRemoteUser(ValueTree user_store , ValueTree subscriptions) { // ensure GUI for this user does not already exist Identifier user_id = user_store.getType() ; if (getChannels(user_id)) return false ; // create remote user GUI addChannels(new RemoteChannels(user_store , subscriptions) , user_id) ; DEBUG_TRACE_ADD_REMOTE_USER return true ; }
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 CtrlrMIDILibrary::setCurrentBank(ValueTree bank) { _DBG("CtrlrMIDILibrary::setCurrentBank from data type="+bank.getType().toString()); if (isBank(bank)) { currentBank = bank; midiBankNumber = getNumber(bank); midiBankNumberLSB = getLSB(bank); midiBankNumberMSB = getMSB(bank); } else { currentBank = ValueTree(); _WRN("CtrlrMIDILibrary::setCurrentBank bank data is invalid"); } listeners.call (&CtrlrMIDILibrary::Listener::programListChanged); }
bool Channels::addChannel(ValueTree channel_store) { DEBUG_TRACE_ADD_CHANNEL_GUI_FAIL // ensure GUI for this channel does not already exist Identifier channel_id = channel_store.getType() ; if (!channel_store.isValid() || getChannel(channel_id)) return false ; // hide stereo slave channels if (int(channel_store[CONFIG::STEREO_ID]) == CONFIG::STEREO_R) return false ; // create channel GUI Channel* channel = newChannel(channel_store) ; addChildAndSetID(channel , String(channel_id)) ; channel->toFront(false) ; // resize and shift channel slices resized() ; DEBUG_TRACE_ADD_CHANNEL_GUI return true ; }
void MDLParser::addTree(ValueTree& rootTree, const ValueTree& newTree) { const Identifier& groupId = ObjectsHelper::getObjectGroup(newTree.getType()); ValueTree group = rootTree.getOrCreateChildWithName(groupId, nullptr); group.addChild(newTree, -1, nullptr); }
StaticStreamViewport::StaticStreamViewport(ValueTree tree_,CriticalSection &lock_, WorkbenchClient* client_) { setName("StaticStreamViewport " + tree_.getType().toString()); setViewedComponent(content = new ContentComponent(tree_,lock_, client_), false); }
const String SAMCompiler::compile(ValueTree mdlRoot_) { String dspContent; //========================================================================== // DSP file header //========================================================================== dspContent << "// This DSP file has been generated by the Synth-A-Modeler compiler.\n"; dspContent << "import(\"physicalmodeling.lib\");\n\n"; //========================================================================== ValueTree faustTree = mdlRoot_.getChildWithName(Objects::variables); ValueTree massTree = mdlRoot_.getChildWithName(Objects::masses); ValueTree linkTree = mdlRoot_.getChildWithName(Objects::links); ValueTree wgTree = mdlRoot_.getChildWithName(Objects::waveguides); ValueTree jTree = mdlRoot_.getChildWithName(Objects::junctions); ValueTree tTree = mdlRoot_.getChildWithName(Objects::terminations); ValueTree aoTree = mdlRoot_.getChildWithName(Objects::audioobjects); int numMasslike = 0; int numPorts = 0; int numWaveguides = 0; int numJunctions = 0; String wgTermString; String junctString; StringArray wgOutputs; StringArray wgInputs; StringArray massWithJunct; StringArray linkWithJunct; StringArray massWithJunctLine; StringArray portWithJunctLine; StringArray massWithJunctOutputs; StringArray junctInputs; StringArray junctOutputs; //========================================================================== //========================================================================== // Write all waveguides and terminations //========================================================================== OwnedArray<WgWithSuffixes> wgWithSuffixes; for (int i = 0; i < wgTree.getNumChildren(); ++i) { ++numWaveguides; ValueTree wg = wgTree.getChild(i); WgWithSuffixes* wws = new WgWithSuffixes(); wws->wgId = wg[Ids::identifier].toString(); ValueTree left = jTree.getChildWithProperty(Ids::identifier, wg[Ids::startVertex]); ValueTree right; if (left.isValid()) { right = tTree.getChildWithProperty(Ids::identifier, wg[Ids::endVertex]); } else { left = tTree.getChildWithProperty(Ids::identifier, wg[Ids::startVertex]); right = jTree.getChildWithProperty(Ids::identifier, wg[Ids::endVertex]); } ValueTree term; ValueTree junct; StringArray wgSuffixes; if (left.getType() == Ids::termination) { wgSuffixes.add(wgR); wgSuffixes.add(wgL); wgSuffixes.add(wgRp); wgSuffixes.add(wgLp); term = left; junct = right; wws->termRight = false; } else if (left.getType() == Ids::junction) { wgSuffixes.add(wgL); wgSuffixes.add(wgR); wgSuffixes.add(wgLp); wgSuffixes.add(wgRp); term = right; junct = left; wws->termRight = true; } wws->wgSuffixes = wgSuffixes; wgInputs.add(wg[Ids::identifier].toString() + wgLp); wgInputs.add(wg[Ids::identifier].toString() + wgRp); wgOutputs.add(wg[Ids::identifier].toString() + wgL); wgOutputs.add(wg[Ids::identifier].toString() + wgR); ValueTree paWg = wg.getChildWithName(Ids::parameters); StringArray paWgStrings; for (int j = 0; j < paWg.getNumChildren(); ++j) { paWgStrings.add(paWg.getChild(j)[Ids::value].toString()); } wws->wgParams = paWgStrings; wgWithSuffixes.add(wws); ValueTree paTerm = term.getChildWithName(Ids::parameters); StringArray paTermStrings; for (int j = 0; j < paTerm.getNumChildren(); ++j) { paTermStrings.add(paTerm.getChild(j)[Ids::value].toString()); } //====================================================================== wgTermString << "\t"; wgTermString << wg[Ids::identifier].toString(); wgTermString << wgSuffixes[0] << " = " << term[Ids::identifier].toString(); wgTermString << " : "; wgTermString << paWgStrings[1]; wgTermString << ";\n\t"; wgTermString << term[Ids::identifier].toString(); wgTermString << " = "; wgTermString << wg[Ids::identifier].toString() << wgSuffixes[3]; wgTermString << " : "; wgTermString << paTermStrings[0] << ";\n\n"; //====================================================================== } //========================================================================== // Write all junctions //========================================================================== for (int i = 0; i < jTree.getNumChildren(); ++i) { ++numJunctions; ValueTree junct = jTree.getChild(i); junctOutputs.add(junct[Ids::identifier].toString()); junctInputs.add(junct[Ids::identifier].toString()+"p"); ValueTree wgs = getWgForJunct(wgTree, junct); StringArray junctWgOuts; StringArray junctWgParams; junctString << "\t"; for (int k = 0; k < wgs.getNumChildren(); ++k) { ValueTree wg = wgs.getChild(k); int wgSuffixesIdx = containsWgRef(wgWithSuffixes, wg[Ids::identifier].toString()); if (wgSuffixesIdx == -1) continue; const StringArray& wgSuffixes = wgWithSuffixes[wgSuffixesIdx]->wgSuffixes; junctString << wg[Ids::identifier].toString() << wgSuffixes[1]; junctString << " = "; junctString << junct[Ids::identifier].toString() << jTO; junctString << wg[Ids::identifier].toString(); junctString << " : "; junctString << wgWithSuffixes[wgSuffixesIdx]->wgParams[1]; junctString << ";\n\t"; junctString << junct[Ids::identifier].toString() << jTO; junctString << wg[Ids::identifier].toString() << " = "; junctString << junct[Ids::identifier].toString() << jOutputs; junctString << ":(_,!)-"; junctString << wg[Ids::identifier].toString() << wgSuffixes[2]; junctString << ";\n\t"; String jwo; jwo << wg[Ids::identifier].toString() << wgSuffixes[2]; jwo << "*" << wgWithSuffixes[wgSuffixesIdx]->wgParams[0]; junctWgOuts.add(jwo); junctWgParams.add(wgWithSuffixes[wgSuffixesIdx]->wgParams[0]); } String junctLinkString; String junctMassString; // Check if junction has one link and mass connected ValueTree junctLink = getJunctionLink(linkTree, junct); if (junctLink.isValid()) { String jm; if (junctLink[Ids::startVertex] == junct[Ids::identifier]) jm << junctLink[Ids::endVertex].toString(); else jm << junctLink[Ids::startVertex].toString(); junctMassString << jm << "p"; massWithJunct.add(jm); massWithJunctOutputs.add(jm + "p"); linkWithJunct.add(junctLink[Ids::identifier].toString()); ValueTree junctLinkParams = junctLink.getChildWithName(Ids::parameters); StringArray junctLinkParamsStrings; for (int k = 0; k < junctLinkParams.getNumChildren(); ++k) { ValueTree param = junctLinkParams.getChild(k); junctLinkParamsStrings.add(param[Ids::value].toString()); } junctLinkString << "junction" << junctLink.getType().toString(); junctLinkString << "Underneath(0.0,"; junctLinkString << junctLinkParamsStrings.joinIntoString(","); junctLinkString << ")"; // Get mass-like object connected with junction > link ValueTree mwj = massTree.getChildWithProperty(Ids::identifier, jm); String mwjl = "\t"; mwjl << jm; mwjl << " = (0.0"; StringArray otherLinks; for (int k = 0; k < linkTree.getNumChildren(); ++k) { ValueTree li = linkTree.getChild(k); if(li[Ids::identifier].toString() == junctLink[Ids::identifier].toString()) continue; if(li[Ids::startVertex].toString() == jm) { otherLinks.add("-"+li[Ids::identifier].toString()); } else if (li[Ids::endVertex].toString() == jm) { otherLinks.add("+"+li[Ids::identifier].toString()); } } mwjl << otherLinks.joinIntoString(String::empty); mwjl << "+("; mwjl << junct[Ids::identifier].toString() << jOutputs << ":(!,_)))"; // mwjl << " : "; // ValueTree mwjp = mwj.getChildWithName(Ids::parameters); // StringArray mwjpStrings; // for (int p = 0; p < mwjp.getNumChildren(); ++p) // { // ValueTree param = mwjp.getChild(p); // mwjpStrings.add(param[Ids::value].toString()); // } // mwjl << mwj.getType().toString(); // mwjl << "(" << mwjpStrings.joinIntoString(",") << ")"; mwjl << ";"; massWithJunctLine.add(mwjl); } else { junctMassString << "0.0"; junctLinkString << "junctionlink(0.0, 0.0, 0.0, 0.0)"; } junctString << junct[Ids::identifier].toString() << jOutputs; junctString << " = ("; junctString << junctMassString << ", 0.0+"; junctString << junctWgOuts.joinIntoString("+"); junctString << ", 0.0+"; junctString << junctWgParams.joinIntoString("+"); junctString << ") : "; junctString << junctLinkString << ";\n\t"; junctString << junct[Ids::identifier].toString(); junctString << " = "; junctString << junct[Ids::identifier].toString() << jOutputs; junctString << ":(_,!);\n\n"; } //========================================================================== // Write all faustcode //========================================================================== for (int i = 0; i < faustTree.getNumChildren(); ++i) { ValueTree fa = faustTree.getChild(i); dspContent << fa[Ids::identifier].toString(); dspContent << "="; dspContent << fa[Ids::faustCode].toString(); dspContent << ";\n"; } dspContent << "\n"; //========================================================================== // Get all mass names //========================================================================== OwnedArray<MassLinkRef> massLinkRefs; for (int i = 0; i < massTree.getNumChildren(); ++i) { ValueTree ma = massTree.getChild(i); if (massWithJunct.contains(ma[Ids::identifier].toString())) continue; MassLinkRef* mlf = new MassLinkRef(); mlf->massId = ma[Ids::identifier].toString(); StringArray mlfa; mlf->linkRefs = mlfa; if (ma.getType() == Ids::port) mlf->isPort = true; else mlf->isPort = false; massLinkRefs.add(mlf); } //========================================================================== // Write all link-like objects //========================================================================== StringArray linkobjects; for (int i = 0; i < linkTree.getNumChildren(); ++i) { ValueTree li = linkTree.getChild(i); String linkId = li[Ids::identifier].toString(); if (linkWithJunct.contains(linkId)) continue; String startVertex = li[Ids::startVertex].toString(); String endVertex = li[Ids::endVertex].toString(); int sIdx = containsMassLinkRef(massLinkRefs, startVertex); if (sIdx >= 0) massLinkRefs[sIdx]->linkRefs.add("-" + linkId); int eIdx = containsMassLinkRef(massLinkRefs, endVertex); if (eIdx >= 0) massLinkRefs[eIdx]->linkRefs.add("+" + linkId); String tagName = li.getType().toString(); ValueTree params = li.getChildWithName(Ids::parameters); StringArray paramsStr; for (int k = 0; k < params.getNumChildren(); ++k) { ValueTree param = params.getChild(k); paramsStr.add(param[Ids::value].toString()); } //====================================================================== String linkLine; linkLine << "\t"; linkLine << linkId; linkLine << " = ("; linkLine << startVertex << "p - "; linkLine << endVertex << "p) : "; linkLine << tagName << "("; linkLine << paramsStr.joinIntoString(",") << ");"; linkobjects.add(linkLine); //====================================================================== } StringArray massobjects; //========================================================================== // write all mass-like object except those connected to junctions //========================================================================== for (int i = 0; i < massTree.getNumChildren(); ++i) { ValueTree ma = massTree.getChild(i); if (massWithJunct.contains(ma[Ids::identifier].toString())) { if(ma.getType().toString().compare("port") == 0) ++numPorts; continue; } ++numMasslike; String tagName = ma.getType().toString(); String massName = ma[Ids::identifier].toString(); String massLine; massLine << "\t"; massLine << massName << " = (0.0"; if (tagName.compare("port") == 0) ++numPorts; int mIdx = containsMassLinkRef(massLinkRefs, massName); if (mIdx >= 0) { if (massLinkRefs[mIdx]->linkRefs.size() > 0) { massLine << massLinkRefs[mIdx]->linkRefs.joinIntoString(String::empty); } } massLine << ")"; if (tagName.compare("port") != 0) { massLine << " : "; massLine << tagName << "("; ValueTree params = ma.getChildWithName(Ids::parameters); StringArray paramsStr; for (int k = 0; k < params.getNumChildren(); ++k) { ValueTree param = params.getChild(k); paramsStr.add(param[Ids::value].toString()); } massLine << paramsStr.joinIntoString(",") << ")"; } massLine << ";"; massobjects.add(massLine); } //========================================================================== // add remaining mass-like object which are connected to junctions //========================================================================== massobjects.addArray(massWithJunctLine); //========================================================================== // Write all audio objects //========================================================================== StringArray audioobjects; StringArray audioNames; for (int i = 0; i < aoTree.getNumChildren(); ++i) { ValueTree ao = aoTree.getChild(i); String audioLine; String audioName = ao[Ids::identifier].toString(); audioNames.add(audioName); audioLine << "\t"; audioLine << audioName << " = "; ValueTree sources = ao.getChildWithName(Ids::sources); String paramLine; StringArray paramsStr; if (sources.getNumChildren() > 0) { for (int k = 0; k < sources.getNumChildren(); ++k) { ValueTree src = sources.getChild(k); paramsStr.add(src[Ids::value].toString()); } paramLine << paramsStr.joinIntoString("+"); } String optional = ao[Ids::optional].toString(); if (optional != String::empty) { if(! paramLine.startsWith("(")) paramLine = "(" + paramLine; if(! paramLine.endsWith(")")) paramLine << ")"; paramLine << optional; } audioLine << paramLine; audioLine << ";"; audioobjects.add(audioLine); } //========================================================================== // Generate all inputs and outputs //========================================================================== StringArray inputs; StringArray inputsPorts; for (int i = 0; i < massLinkRefs.size(); ++i) { if (massLinkRefs[i]->isPort) inputsPorts.add(massLinkRefs[i]->massId); else inputs.add(massLinkRefs[i]->massId); } StringArray outputs = inputs; outputs.addArray(massWithJunct); StringArray outputsPorts = inputsPorts; StringArray inputsP; StringArray inputsPPorts; for (int i = 0; i < inputs.size(); ++i) { String inputP = inputs[i]; inputP << "p"; inputsP.add(inputP); } for (int i = 0; i < massWithJunctOutputs.size(); ++i) { ++numMasslike; String inputP = massWithJunctOutputs[i]; inputsP.add(inputP); } for (int i = 0; i < inputsPorts.size(); ++i) { String inputPPort = inputsPorts[i]; inputPPort << "p"; inputsPPorts.add(inputPPort); } //========================================================================== // bibBlock with all imputs and outputs //========================================================================== dspContent << "bigBlock(" << inputsP.joinIntoString(","); if (wgInputs.size() > 0) dspContent << "," << wgInputs.joinIntoString(","); if (junctInputs.size() > 0) dspContent << "," << junctInputs.joinIntoString(","); if (inputsPPorts.size() > 0) dspContent << "," << inputsPPorts.joinIntoString(","); dspContent << ") = ("; dspContent << outputs.joinIntoString(","); if (wgOutputs.size() > 0) dspContent << "," << wgOutputs.joinIntoString(","); if (junctOutputs.size() > 0) dspContent << "," << junctOutputs.joinIntoString(","); if (outputsPorts.size() > 0) dspContent << "," << outputsPorts.joinIntoString(","); if (audioNames.size() > 0) dspContent << "," << audioNames.joinIntoString(","); dspContent << ") with {\n"; //========================================================================== // code for model objects //========================================================================== dspContent << "\n\t//waveguide termination objects\n"; dspContent << wgTermString; dspContent << "\t//junctions\n"; dspContent << junctString; dspContent << "\t//mass-like objects\n"; dspContent << massobjects.joinIntoString("\n") << "\n"; dspContent << "\n\t//link-like objects\n"; dspContent << linkobjects.joinIntoString("\n") << "\n"; dspContent << "\n\t//audio objects\n"; dspContent << audioobjects.joinIntoString("\n") << "\n};\n\n"; //========================================================================== // Calculate and write feedback line //========================================================================== StringArray feedbackArray; StringArray outputArray; //TODO: needs to be fixed for latest Synth-A-Modeler changes/fiyes int numFeedback = numMasslike - numPorts + (2 * numWaveguides) + numJunctions; for (int i = 0; i < numFeedback; ++i) { feedbackArray.add("_"); outputArray.add("!"); } for (int i = 0; i < numPorts + audioNames.size(); ++i) { feedbackArray.add("!"); outputArray.add("_"); } dspContent << "process = (bigBlock)~("; dspContent << feedbackArray.joinIntoString(","); dspContent << "):("; dspContent << outputArray.joinIntoString(",") << ");"; //========================================================================== massLinkRefs.clear(); wgWithSuffixes.clear(); return dspContent; }
void MidiControllerAutomationHandler::restoreFromValueTree(const ValueTree &v) { if (v.getType() != Identifier("MidiAutomation")) return; clear(); for (int i = 0; i < v.getNumChildren(); i++) { ValueTree cc = v.getChild(i); int controller = cc.getProperty("Controller", 1); auto& aArray = automationData[controller]; AutomationData a; a.ccNumber = controller; a.processor = ProcessorHelpers::getFirstProcessorWithName(mc->getMainSynthChain(), cc.getProperty("Processor")); a.macroIndex = cc.getProperty("MacroIndex"); auto attributeString = cc.getProperty("Attribute", a.attribute).toString(); const bool isParameterId = attributeString.containsAnyOf("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"); // The parameter was stored correctly as ID if (isParameterId && a.processor.get() != nullptr) { const Identifier pId(attributeString); for (int j = 0; j < a.processor->getNumParameters(); j++) { if (a.processor->getIdentifierForParameterIndex(j) == pId) { a.attribute = j; break; } } } else { // This tries to obtain the correct id. auto presetVersion = v.getRoot().getProperty("Version").toString(); const Identifier pId = UserPresetHelpers::getAutomationIndexFromOldVersion(presetVersion, attributeString.getIntValue()); if (pId.isNull()) { a.attribute = attributeString.getIntValue(); } else { for (int j = 0; j < a.processor->getNumParameters(); j++) { if (a.processor->getIdentifierForParameterIndex(j) == pId) { a.attribute = j; break; } } } } double start = cc.getProperty("Start"); double end = cc.getProperty("End"); double skew = cc.getProperty("Skew", a.parameterRange.skew); double interval = cc.getProperty("Interval", a.parameterRange.interval); auto fullStart = cc.getProperty("FullStart", start); auto fullEnd = cc.getProperty("FullEnd", end); a.parameterRange = NormalisableRange<double>(start, end, interval, skew); a.fullRange = NormalisableRange<double>(fullStart, fullEnd, interval, skew); a.used = true; a.inverted = cc.getProperty("Inverted", false); aArray.addIfNotAlreadyThere(a); } sendChangeMessage(); refreshAnyUsedState(); }
bool MDLParser::parseMDL(const File& f) { RegularExpression re; RegularExpression reComment("\\A\\s*#[^#].*$"); const File& in = f;//mdlFile.getFile(); String mdlContent = in.loadFileAsString(); ValueTree mdlTree(Objects::synthamodeler);// = mdlFile.mdlRoot; mdlTree.setProperty(Ids::mdlName, in.getFileName(), nullptr); mdlTree.setProperty(Ids::mdlPath, in.getFullPathName(), nullptr); StringArray lines; lines.addTokens(mdlContent, "\n", "\""); for (int i = 0; i < lines.size(); ++i) { String line = lines[i]; if(reComment.fullMatch(line) || line.isEmpty()) { continue; } if(re.fullMatch(SAMRegex::getVertexLine(), line)) { StringArray values; re.fullMatchValues(line, values, 4); ValueTree newTree; if (values[0].compare("mass") == 0) { newTree = ValueTree(Ids::mass); } else if (values[0].compare("port") == 0) { newTree = ValueTree(Ids::port); } else if (values[0].compare("ground") == 0) { newTree = ValueTree(Ids::ground); } else if (values[0].compare("resonators") == 0) { newTree = ValueTree(Ids::resonators); } else { DBG("Something went really wrong!"); return false; } Point<int> pos = getPos(line); newTree.setProperty(Ids::posX, pos.getX(), nullptr); newTree.setProperty(Ids::posY, pos.getY(), nullptr); if(newTree.getType() != Ids::port && newTree.getType() != Ids::ground) { StringArray paramsArray = MDLHelper::getParamsFromString(values[1]); if(newTree.getType() == Ids::resonators) { static const int NUM_RES_PARAMS = 3; if(paramsArray.size() % NUM_RES_PARAMS == 0) { ValueTree paramsTree(Ids::parameters); Array<ValueTree> valuesArr; for (int np = 0; np < NUM_RES_PARAMS; ++np) { valuesArr.add(ValueTree(Ids::parameter)); } for (int n = 0; n < paramsArray.size(); ++n) { const int paramIdx = n % NUM_RES_PARAMS; ValueTree subVal(ObjectsHelper::getResonatorParamsIds()[paramIdx]); subVal.setProperty(Ids::value, paramsArray[n].trim(), nullptr); valuesArr[paramIdx].addChild(subVal, -1, nullptr); } for (int np = 0; np < NUM_RES_PARAMS; ++np) { paramsTree.addChild(valuesArr[np], -1, nullptr); } newTree.addChild(paramsTree, -1, nullptr); } } else { newTree.addChild(ObjectFactory::createParamsTree(paramsArray), -1, nullptr); } } if(newTree.getType() == Ids::ground) { ValueTree paramsTree(Ids::parameters); ValueTree param(Ids::parameter); param.setProperty(Ids::value, values[1].trim(), nullptr); paramsTree.addChild(param, -1, nullptr); newTree.addChild(paramsTree, -1, nullptr); } newTree.setProperty(Ids::identifier, values[2].trim(), nullptr); ValueTree masses = mdlTree.getOrCreateChildWithName(Objects::masses, nullptr); masses.addChild(newTree, -1, nullptr); } else if(re.fullMatch(SAMRegex::getLinkLine(), line)) { StringArray values; re.fullMatchValues(line, values, 5); ValueTree linkTree; if (values[0].compare("link") == 0) { linkTree = ValueTree(Ids::link); } else if (values[0].compare("touch") == 0) { linkTree = ValueTree(Ids::touch); } else if (values[0].compare("pulsetouch") == 0) { linkTree = ValueTree(Ids::pulsetouch); } else if (values[0].compare("pluck") == 0) { linkTree = ValueTree(Ids::pluck); } else if (values[0].compare("detent") == 0) { linkTree = ValueTree(Ids::detent); } else if (values[0].compare("softeninglink") == 0) { linkTree = ValueTree(Ids::softeninglink); } else if (values[0].compare("stiffeninglink") == 0) { linkTree = ValueTree(Ids::stiffeninglink); } else { DBG("Something went really wrong!"); return false; } StringArray paramsArray = MDLHelper::getParamsFromString(values[1]); linkTree.addChild(ObjectFactory::createParamsTree(paramsArray), -1, nullptr); linkTree.setProperty(Ids::identifier, values[2].trim(), nullptr); linkTree.setProperty(Ids::startVertex, values[3].trim(), nullptr); linkTree.setProperty(Ids::endVertex, values[4].trim(), nullptr); ValueTree linksTree = mdlTree.getOrCreateChildWithName(Objects::links, nullptr); linksTree.addChild(linkTree, -1, nullptr); } else if(re.fullMatch(SAMRegex::getFaustCodeLine(), line)) { StringArray values; re.fullMatchValues(line, values, 1); ValueTree faustcodeTree(Ids::faustcode); faustcodeTree.setProperty(Ids::value, values[0].trim(), nullptr); ValueTree fcbTree = mdlTree.getOrCreateChildWithName(Objects::faustcodeblock, nullptr); fcbTree.addChild(faustcodeTree, -1, nullptr); } else if(re.fullMatch(SAMRegex::getAudioOutLine(), line)) { StringArray values; re.fullMatchValues(line, values, 3); Point<int> pos = getPos(line); ValueTree audioTree(Ids::audioout); audioTree.setProperty(Ids::posX, pos.x, nullptr); audioTree.setProperty(Ids::posY, pos.y, nullptr); audioTree.setProperty(Ids::identifier, values[0].trim(), nullptr); // split everything from line starting with first colon int posColon = values[1].indexOf(":"); String audioLine; if(posColon > 0) { audioLine = values[1].substring(0, posColon); audioLine = MDLHelper::removeUnbalancedParentheses(audioLine); audioTree.setProperty(Ids::optional,values[1].substring(posColon+1), nullptr); } else { audioTree.setProperty(Ids::optional, "", nullptr); audioLine = values[1]; } // add outputDSP to optional values if not present if(! audioTree[Ids::optional].toString().contains("outputDSP")) { String aoOpt = audioTree[Ids::optional].toString(); if(aoOpt.isNotEmpty()) { aoOpt = ":" + aoOpt; } String aoOpt2 = "outputDSP" + aoOpt; audioTree.setProperty(Ids::optional, aoOpt2, nullptr); } // remove unbalanced parentheses audioLine = MDLHelper::removeUnbalancedParentheses(audioLine); // remove surrounding paranthese if there are some. String audioLineClean = MDLHelper::removeSurroundingParentheses(audioLine); StringArray audioOutSourcesList; audioOutSourcesList.addTokens(audioLineClean, "+", "\""); ValueTree audioSources(Ids::sources); for (int l = 0; l < audioOutSourcesList.size(); ++l) { if(audioOutSourcesList[l].trim().compare("0.0") != 0) { ValueTree aoSource(Ids::audiosource); aoSource.setProperty(Ids::value, audioOutSourcesList[l].trim(), nullptr); audioSources.addChild(aoSource, -1, nullptr); } } audioTree.addChild(audioSources, -1, nullptr); ValueTree audioObjectsTree = mdlTree.getOrCreateChildWithName(Objects::audioobjects, nullptr); audioObjectsTree.addChild(audioTree, -1, nullptr); } else if(re.fullMatch(SAMRegex::getWaveguideLine(), line)) { StringArray values; re.fullMatchValues(line, values, 5); ValueTree waveguideTree(Ids::waveguide); StringArray paramsArray(values.begin(), 2); waveguideTree.addChild(ObjectFactory::createParamsTree(paramsArray), -1, nullptr); waveguideTree.setProperty(Ids::identifier, values[2].trim(), nullptr); waveguideTree.setProperty(Ids::startVertex, values[3].trim(), nullptr); waveguideTree.setProperty(Ids::endVertex, values[4].trim(), nullptr); ValueTree wavesTree = mdlTree.getOrCreateChildWithName(Objects::waveguides, nullptr); wavesTree.addChild(waveguideTree, -1, nullptr); } else if(re.fullMatch(SAMRegex::getTerminationLine(), line)) { StringArray values; re.fullMatchValues(line, values, 4); Point<int> pos = getPos(line); ValueTree terminationTree(Ids::termination); terminationTree.setProperty(Ids::posX, pos.x, nullptr); terminationTree.setProperty(Ids::posY, pos.y, nullptr); StringArray paramsArray = MDLHelper::getParamsFromString(values[1]); terminationTree.addChild(ObjectFactory::createParamsTree(paramsArray), -1, nullptr); terminationTree.setProperty(Ids::identifier, values[2].trim(), nullptr); ValueTree terminations = mdlTree.getOrCreateChildWithName(Objects::terminations, nullptr); terminations.addChild(terminationTree, -1, nullptr); } else if(re.fullMatch(SAMRegex::getJunctionLine(), line)) { StringArray values; re.fullMatchValues(line, values, 4); Point<int> pos = getPos(line); ValueTree junctTree(Ids::junction); junctTree.setProperty(Ids::posX, pos.x, nullptr); junctTree.setProperty(Ids::posY, pos.y, nullptr); ValueTree junctParams(Ids::parameters); ValueTree junctParam(Ids::parameter); junctParam.setProperty(Ids::value, values[1].trim(), nullptr); junctParams.addChild(junctParam, -1, nullptr); junctTree.addChild(junctParams, -1, nullptr); junctTree.setProperty(Ids::identifier, values[2].trim(), nullptr); ValueTree junctsTree = mdlTree.getOrCreateChildWithName(Objects::junctions, nullptr); junctsTree.addChild(junctTree, -1, nullptr); } else if(re.fullMatch(SAMRegex::getCommentObjectLine(), line)) { StringArray values; if(! re.fullMatchValues(line, values, 3)) { DBG("Error reading comment object!"); } ValueTree newTree(Ids::comment); Point<int> pos = getPos(line); newTree.setProperty(Ids::posX, pos.getX(), nullptr); newTree.setProperty(Ids::posY, pos.getY(), nullptr); newTree.setProperty(Ids::identifier, values[2], nullptr); StringArray paramsArray = MDLHelper::getParamsFromString(values[1]); StringArray commVal; commVal.addTokens(paramsArray[0].unquoted(), "|" , "\""); newTree.setProperty(Ids::value, commVal.joinIntoString("\n"), nullptr); newTree.setProperty(Ids::fontSize, paramsArray[1], nullptr); newTree.setProperty(Ids::commentColour, paramsArray[2], nullptr); ValueTree comments = mdlTree.getOrCreateChildWithName(Objects::comments, nullptr); comments.addChild(newTree, -1, nullptr); } } // DBG(mdlTree.toXmlString()); mdlFile.mdlRoot = mdlTree; return true; }
void ChannelViewport::valueTreeChildAdded( ValueTree& parentTree, ValueTree& childWhichHasBeenAdded ) { DBG("ChannelViewport::valueTreeChildAdded " << parentTree.getType().toString() << " " << childWhichHasBeenAdded.getType().toString()); triggerAsyncUpdate(); }
//------------------------------------------------------------------------------ //values: mass-type, parameters, identifier ValueTree MDLParser::getMassTree(const String& line, RegularExpression& re) { StringArray values; re.fullMatchValues(line, values, 3); ValueTree newTree = ObjectFactory::getMassTreeFromStringId(values[0]); if (!newTree.isValid()) { throw std::runtime_error("Cannot parse mass-like object"); } const Point<int> pos = getPos(line); newTree.setProperty(Ids::posX, pos.getX(), nullptr); newTree.setProperty(Ids::posY, pos.getY(), nullptr); if (newTree.getType() != Ids::port && newTree.getType() != Ids::ground) { StringArray paramsArray = MDLHelper::getParamsFromString(values[1]); if (newTree.getType() == Ids::resonators) { static const int NUM_RES_PARAMS = 3; if(paramsArray.size() % NUM_RES_PARAMS == 0) { ValueTree paramsTree(Ids::parameters); Array<ValueTree> valuesArr; for (int np = 0; np < NUM_RES_PARAMS; ++np) { valuesArr.add(ValueTree(Ids::parameter)); } for (int n = 0; n < paramsArray.size(); ++n) { const int paramIdx = n % NUM_RES_PARAMS; ValueTree subVal(ObjectsHelper::getResonatorParamsIds()[paramIdx]); subVal.setProperty(Ids::value, paramsArray[n].trim(), nullptr); valuesArr[paramIdx].addChild(subVal, -1, nullptr); } for (int np = 0; np < NUM_RES_PARAMS; ++np) { paramsTree.addChild(valuesArr[np], -1, nullptr); } newTree.addChild(paramsTree, -1, nullptr); } } else { newTree.addChild(ObjectFactory::createParamsTree(paramsArray), -1, nullptr); } } else if (newTree.getType() == Ids::ground) { ValueTree paramsTree(Ids::parameters); ValueTree param(Ids::parameter); param.setProperty(Ids::value, values[1].trim(), nullptr); paramsTree.addChild(param, -1, nullptr); newTree.addChild(paramsTree, -1, nullptr); } newTree.setProperty(Ids::identifier, values[2].trim(), nullptr); return newTree; }