void CtrlrMIDILibrary::addNewProgram (const String programName, const int number, ValueTree unitToAddTo) { ValueTree program = createEmptyProgramTree(); program.addChild (owner.getProgram(), -1, nullptr); program.setProperty (Ids::name, getDefaultProgramName(programName), nullptr); program.setProperty (Ids::description, String::empty, nullptr); program.setProperty (Ids::number, getCurrentProgramMIDINumber(number), nullptr); program.setProperty (Ids::uuid, Uuid().toString(), nullptr); if (unitToAddTo.isValid()) { unitToAddTo.addChild (program, -1, 0); } else { if (isBank(getCurrentBank())) { getCurrentBank().addChild (program, -1, 0); } else { getRoot().addChild (program, -1, 0); } } listeners.call (&CtrlrMIDILibrary::Listener::programListChanged); }
void Project::addNewExporter (const String& exporterName) { ScopedPointer<ProjectExporter> exp (ProjectExporter::createNewExporter (*this, exporterName)); ValueTree exporters (getExporters()); exporters.addChild (exp->settings, -1, getUndoManagerFor (exporters)); }
ObjectComponent* ObjController::addObject(ObjectsHolder* holder, ValueTree objValues, int index, bool undoable) { if(undoable) { AddObjectAction* action = new AddObjectAction(this, objValues, holder); owner.getUndoManager().perform(action, "Add new Object"); return objects[action->indexAdded]; } else { const Identifier& groupName = ObjectsHelper::getObjectGroup(objValues.getType().toString()); ValueTree mdl = owner.getMDLTree(); ValueTree subTree = mdl.getOrCreateChildWithName(groupName, nullptr); subTree.addChild(objValues,-1, nullptr); idMgr->addId(objValues.getType(), objValues[Ids::identifier].toString(), nullptr); ObjectComponent* objComp = new ObjectComponent(*this, objValues); objects.insert(index, objComp); holder->addAndMakeVisible(objComp); changed(); return objComp; } return 0; }
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::addNewExporter (int exporterIndex) { ScopedPointer<ProjectExporter> exp (ProjectExporter::createNewExporter (*this, exporterIndex)); ValueTree exporters (getExporters()); exporters.addChild (exp->getSettings(), -1, getUndoManagerFor (exporters)); }
AudioOutConnector* ObjController::addAudioConnection(ObjectsHolder* holder, BaseObjectComponent* objComp, ObjectComponent* audioOutComp, ValueTree source, int index, bool undoable) { if(undoable) { AddAudioConnectionAction* action = new AddAudioConnectionAction( this, objComp, source, audioOutComp, holder); owner.getUndoManager().perform(action, "Add new audio connection"); return audioConnections[action->indexAdded]; } else { AudioOutConnector* aoc = new AudioOutConnector(*this, objComp, audioOutComp); ValueTree sources = aoc->getAudioObject()->getData().getChildWithName(Ids::sources); if(! sources.getChildWithProperty(Ids::value, source[Ids::value]).isValid()) sources.addChild(source, -1, nullptr); audioConnections.insert(index, aoc); holder->addAndMakeVisible(aoc); aoc->update(); aoc->toBack(); return aoc; } return nullptr; }
void CtrlrMIDILibrary::addNewTransaction (const String transactionName, ValueTree unitToAddTo) { ValueTree transaction = CtrlrMIDITransaction::createEmptyTransactionTree(transactionName); if (unitToAddTo.isValid()) { unitToAddTo.addChild (transaction, -1, nullptr); } }
void DrawablePath::ValueTreeWrapper::readFrom (const RelativePointPath& relativePath, UndoManager* undoManager) { setUsesNonZeroWinding (relativePath.usesNonZeroWinding, undoManager); ValueTree pathTree (getPathState()); pathTree.removeAllChildren (undoManager); for (int i = 0; i < relativePath.elements.size(); ++i) pathTree.addChild (relativePath.elements.getUnchecked(i)->createTree(), -1, undoManager); }
int ksp1_db_query (void* arg, int count, char** values, char** fields) { ValueTree* tree = (ValueTree*) arg; ValueTree row ("row"); for (int i = 0; i < count; ++i) { row.setProperty (fields[i], values[i], nullptr); } tree->addChild (row, -1, nullptr); return SQLITE_OK; }
ValueTree ValueTree::fromXml (const XmlElement& xml) { ValueTree v (xml.getTagName()); const int numAtts = xml.getNumAttributes(); // xxx inefficient - should write an att iterator.. for (int i = 0; i < numAtts; ++i) v.setProperty (xml.getAttributeName (i), var (xml.getAttributeValue (i)), 0); forEachXmlChildElement (xml, e) { v.addChild (fromXml (*e), -1, 0); }
ValueTree AudioProcessorValueTreeState::getOrCreateChildValueTree (const String& paramID) { ValueTree v (state.getChildWithProperty (idPropertyID, paramID)); if (! v.isValid()) { v = ValueTree (valueType); v.setProperty (idPropertyID, paramID, undoManager); state.addChild (v, -1, undoManager); } return v; }
ValueTree ScannerManagerComponent::getForDocument() { ValueTree data ("SCANNERS"); for (unsigned i = 0; i < cues.size(); i++) { ValueTree cue ("CUE"); cue.setProperty ("x", cues[i]->getPosition(), nullptr); data.addChild (cue, i, nullptr); } return data; }
void Project::addModule (const String& moduleID, bool shouldCopyFilesLocally) { if (! isModuleEnabled (moduleID)) { ValueTree module (Tags::module); module.setProperty (Ids::ID, moduleID, nullptr); ValueTree modules (getModulesNode()); modules.addChild (module, -1, getUndoManagerFor (modules)); shouldShowAllModuleFilesInProject (moduleID) = true; } if (shouldCopyFilesLocally) shouldCopyModuleFilesLocally (moduleID) = true; }
Value ProjectExporter::getPathForModuleValue (const String& moduleID) { UndoManager* um = project.getUndoManagerFor (settings); ValueTree paths (settings.getOrCreateChildWithName (Ids::MODULEPATHS, um)); ValueTree m (paths.getChildWithProperty (Ids::ID, moduleID)); if (! m.isValid()) { m = ValueTree (Ids::MODULEPATH); m.setProperty (Ids::ID, moduleID, um); paths.addChild (m, -1, um); } return m.getPropertyAsValue (Ids::path, um); }
void CtrlrMIDILibrary::snapshot() { ValueTree snapshotTree = createEmptyProgramTree(); snapshotTree.setProperty (Ids::time, Time::getCurrentTime().toMilliseconds(), nullptr); snapshotTree.setProperty (Ids::name, getDefaultSnapshotName(), nullptr); snapshotTree.setProperty (Ids::uuid, Uuid().toString(), nullptr); snapshotTree.addChild (owner.getProgram(), -1, nullptr); if (getSnapshots().isValid()) { if (getSnapshots().isValid()) { getSnapshots().addChild (snapshotTree, -1, nullptr); } } }
void CtrlrPanelCanvas::copyWithChildren(CtrlrComponent *c) { if (c) { ValueTree clipboardTree("groupTree"); ValueTree groupTree = c->getOwner().getObjectTree().createCopy(); Array<CtrlrComponent*> children = c->getOwnedChildren(); for (int i=0; i<children.size(); i++) { ValueTree childTreeCopy = children[i]->getOwner().getObjectTree().createCopy(); childTreeCopy.removeProperty(Ids::vstIndex, nullptr); groupTree.addChild (childTreeCopy, -1, 0); } clipboardTree.addChild (groupTree, -1, 0); SystemClipboard::copyTextToClipboard (XML2STR(clipboardTree)); } }
void CtrlrMIDILibrary::addNewCustomData (const String dataName, const int number, ValueTree unitToAddTo) { ValueTree data(Ids::midiLibraryData); data.setProperty (Ids::name, dataName, nullptr); data.setProperty (Ids::description, String::empty, nullptr); data.setProperty (Ids::number, number, nullptr); data.setProperty (Ids::midiLibraryCanGetItem, true, nullptr); data.setProperty (Ids::midiLibraryCanSendItem, true, nullptr); data.setProperty (Ids::uuid, Uuid().toString(), nullptr); if (unitToAddTo.isValid()) { unitToAddTo.addChild (data, -1, nullptr); } else { getRoot().addChild (data, -1, nullptr); } }
void Project::addNewConfiguration (BuildConfiguration* configToCopy) { const String configName (getUniqueConfigName (configToCopy != nullptr ? configToCopy->config [Ids::name].toString() : "New Build Configuration")); ValueTree configs (getConfigurations()); if (! configs.isValid()) { projectRoot.addChild (ValueTree (Tags::configurations), 0, getUndoManagerFor (projectRoot)); configs = getConfigurations(); } ValueTree newConfig (Tags::configuration); if (configToCopy != nullptr) newConfig = configToCopy->config.createCopy(); newConfig.setProperty (Ids::name, configName, 0); configs.addChild (newConfig, -1, getUndoManagerFor (configs)); }
void ProjectExporter::addNewConfiguration (const BuildConfiguration* configToCopy) { const String configName (getUniqueConfigName (configToCopy != nullptr ? configToCopy->config [Ids::name].toString() : "New Build Configuration")); ValueTree configs (getConfigurations()); if (! configs.isValid()) { settings.addChild (ValueTree (Ids::CONFIGURATIONS), 0, project.getUndoManagerFor (settings)); configs = getConfigurations(); } ValueTree newConfig (Ids::CONFIGURATION); if (configToCopy != nullptr) newConfig = configToCopy->config.createCopy(); newConfig.setProperty (Ids::name, configName, 0); configs.addChild (newConfig, -1, project.getUndoManagerFor (configs)); }
void CtrlrLuaMethodEditor::itemDropped (ValueTree &targetItem, const DragAndDropTarget::SourceDetails &dragSourceDetails, int insertIndex) { if ( (targetItem.hasType(Ids::luaMethodGroup) || targetItem.hasType(Ids::luaManagerMethods)) && insertIndex == 0 ) { StringArray ar; ar.addTokens (dragSourceDetails.description.toString(), ";", "\"'"); for (int i=0; i<ar.size(); i++) { CtrlrValueTreeEditorItem *sourceItem = dynamic_cast<CtrlrValueTreeEditorItem*>(methodTree->findItemFromIdentifierString (ar[i])); if (sourceItem != nullptr) { ValueTree child = sourceItem->getTree(); ValueTree parent = child.getParent(); parent.removeChild (child, nullptr); targetItem.addChild (child, -1, nullptr); } } triggerAsyncUpdate(); } }
//------------------------------------------------------------------------------ // values: link-type, parameters, identifier, startVertex, endVertex ValueTree MDLParser::getLinkTree(const String& line, RegularExpression& re) { StringArray values; re.fullMatchValues(line, values, 5); ValueTree linkTree = ObjectFactory::getLinkTreeFromStringId(values[0]); if (!linkTree.isValid()) { throw std::runtime_error("Could not parse link-like object"); } 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); return linkTree; }
ValueTree DrawableComposite::createValueTree (ComponentBuilder::ImageProvider* imageProvider) const { ValueTree tree (valueTreeType); ValueTreeWrapper v (tree); v.setID (getComponentID()); v.setBoundingBox (bounds, nullptr); ValueTree childList (v.getChildListCreating (nullptr)); for (int i = 0; i < getNumChildComponents(); ++i) { const Drawable* const d = dynamic_cast <const Drawable*> (getChildComponent(i)); jassert (d != nullptr); // You can't save a mix of Drawables and normal components! childList.addChild (d->createValueTree (imageProvider), -1, nullptr); } v.getMarkerListCreating (true, nullptr).readFrom (markersX, nullptr); v.getMarkerListCreating (false, nullptr).readFrom (markersY, nullptr); return tree; }
void CtrlrMIDILibrary::addNewBank (const String bankName, const String bankDescription, const int number, const int lsb, const int msb, ValueTree unitToAddTo) { ValueTree b(Ids::midiLibraryBank); b.setProperty (Ids::name, getDefaultBankName (bankName), 0); b.setProperty (Ids::description, bankDescription, 0); b.setProperty (Ids::lsb, lsb, nullptr); b.setProperty (Ids::msb, msb, nullptr); b.setProperty (Ids::number, getCurrentBankMIDINumber (number), nullptr); b.setProperty (Ids::midiLibraryCanGetItem, true, nullptr); b.setProperty (Ids::midiLibraryCanSendItem, true, nullptr); b.setProperty (Ids::uuid, Uuid().toString(), nullptr); if (unitToAddTo.isValid()) { unitToAddTo.addChild (b, -1, nullptr); } else { getRoot().addChild(b, -1, nullptr); } listeners.call (&CtrlrMIDILibrary::Listener::programListChanged); }
ValueTree CtrlrPanel::getProgram(ValueTree treeToWriteTo) { if (treeToWriteTo.isValid()) { treeToWriteTo.removeAllChildren(0); } ValueTree program(Ids::panelState); program.setProperty (Ids::panelVersionMajor, getProperty(Ids::panelVersionMajor), 0); program.setProperty (Ids::panelVersionMinor, getProperty(Ids::panelVersionMinor), 0); program.setProperty (Ids::time, Time::getCurrentTime().currentTimeMillis(), 0); for (int i=0; i<ctrlrModulators.size(); i++) { CtrlrModulator *m = ctrlrModulators[i]; ValueTree v(Ids::value); if ((bool)m->getProperty (Ids::modulatorIsStatic) == true) continue; v.setProperty(Ids::name, m->getName(),0); v.setProperty(Ids::value, m->getModulatorValue(),0); if (treeToWriteTo.isValid()) { treeToWriteTo.addChild (v,-1,0); } else { program.addChild (v,-1,0); } } return (program); }
void StateWriter::getState (MemoryBlock& destData) { DBG("StateWriter::getState(): Saving state.") ValueTree settingsTree ("settings"); ValueTree libTree ("library"); libTree.setProperty ("threshold", library->getThreshold(), nullptr); libTree.setProperty ("release", library->getReleaseTicks(), nullptr); libTree.setProperty ("velocity", library->getVelocityScale(), nullptr); settingsTree.addChild (libTree, -1, nullptr); ValueTree patternsTree ("patterns"); for (int i = 0; i < library->getNumPatterns(); i++) { Pattern* pattern = library->getPattern (i); ValueTree patternTree ("pattern"); ValueTree instrumentsTree ("instruments"); for (int j = 0; j < pattern->getNumInstruments(); j++) { Instrument* instrument = pattern->getInstrumentAt (j); ValueTree instrumentTree ("instrument"); instrumentTree.setProperty ("index", instrument->getIndex(), nullptr); instrumentTree.setProperty ("name", instrument->getName(), nullptr); instrumentTree.setProperty ("noteNumber", instrument->getNoteNumber(), nullptr); instrumentsTree.addChild (instrumentTree, -1, nullptr); } patternTree.addChild (instrumentsTree, -1, nullptr); patternsTree.addChild (patternTree, -1, nullptr); } settingsTree.addChild (patternsTree, -1, nullptr); ValueTree seqTree ("sequencer"); seqTree.setProperty ("sequencerNum", sequencer->getSequencerNum(), nullptr); settingsTree.addChild (seqTree, -1, nullptr); MemoryOutputStream stream (destData, false); settingsTree.writeToStream (stream); }
void AssetTree::addChildInternal (ValueTree& parent, ValueTree& child) { parent.addChild (child, -1, undo); }
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); }
//------------------------------------------------------------------------------ //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; }
bool ValueTreeSynchroniser::applyChange (ValueTree& root, const void* data, size_t dataSize, UndoManager* undoManager) { MemoryInputStream input (data, dataSize, false); const ValueTreeSynchroniserHelpers::ChangeType type = (ValueTreeSynchroniserHelpers::ChangeType) input.readByte(); if (type == ValueTreeSynchroniserHelpers::fullSync) { root = ValueTree::readFromStream (input); return true; } ValueTree v (ValueTreeSynchroniserHelpers::readSubTreeLocation (input, root)); if (! v.isValid()) return false; switch (type) { case ValueTreeSynchroniserHelpers::propertyChanged: { Identifier property (input.readString()); v.setProperty (property, var::readFromStream (input), undoManager); return true; } case ValueTreeSynchroniserHelpers::propertyRemoved: { Identifier property (input.readString()); v.removeProperty (property, undoManager); return true; } case ValueTreeSynchroniserHelpers::childAdded: { const int index = input.readCompressedInt(); v.addChild (ValueTree::readFromStream (input), index, undoManager); return true; } case ValueTreeSynchroniserHelpers::childRemoved: { const int index = input.readCompressedInt(); if (isPositiveAndBelow (index, v.getNumChildren())) { v.removeChild (index, undoManager); return true; } jassertfalse; // Either received some corrupt data, or the trees have drifted out of sync break; } case ValueTreeSynchroniserHelpers::childMoved: { const int oldIndex = input.readCompressedInt(); const int newIndex = input.readCompressedInt(); if (isPositiveAndBelow (oldIndex, v.getNumChildren()) && isPositiveAndBelow (newIndex, v.getNumChildren())) { v.moveChild (oldIndex, newIndex, undoManager); return true; } jassertfalse; // Either received some corrupt data, or the trees have drifted out of sync break; } default: jassertfalse; // Seem to have received some corrupt data? break; } return false; }
//============================================================================== void AnalysisModel::addNewAnalysis(ValueTree analyserTree, ValueTree newNode) { analyserTree.addChild(newNode, -1, nullptr); }