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