void ObjController::removeLink(LinkComponent* linkComp, bool undoable, ObjectsHolder* holder)
{
if (undoable)
{
owner.getUndoManager().perform(new RemoveLinkAction(holder, linkComp, this));
}
else
{
sObjects.deselect(linkComp);
sObjects.changed(true);
Array<int> aoIndices = checkIfObjectHasAudioConnections(linkComp->getData());
for(int i = aoIndices.size(); --i >= 0;)
{
removeAudioConnection(getAudioConnector(aoIndices[i]), true, holder);
}
const Identifier& groupName = ObjectsHelper::getObjectGroup(linkComp->getData().getType());
ValueTree mdl = owner.getMDLTree();
ValueTree subTree = mdl.getOrCreateChildWithName(groupName, nullptr);
idMgr->removeId(linkComp->getData().getType(),
linkComp->getData()[Ids::identifier].toString(), nullptr);
subTree.removeChild(linkComp->getData(), nullptr);
links.removeObject(linkComp);
}
}
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);
}
}
bool MDLParser::parseMDLX(const File& f, bool onlyExtras)
{
XmlElement* xml = XmlDocument::parse(f);
if (xml != nullptr)
{
ValueTree mdlxTree = ValueTree::fromXml(*xml);
if (onlyExtras)
{
ValueTree comments = mdlxTree.getChildWithName(Objects::comments);
if(comments.isValid())
{
mdlxTree.removeChild(comments, nullptr);
ValueTree tmp1 = mdlxTree.createCopy();
ValueTree tmp2 = mdlFile.mdlRoot.createCopy();
tmp1.setProperty(Ids::mdlName, "", nullptr);
tmp1.setProperty(Ids::mdlPath, "", nullptr);
tmp2.setProperty(Ids::mdlName, "", nullptr);
tmp2.setProperty(Ids::mdlPath, "", nullptr);
if(tmp1.isEquivalentTo(tmp2))
mdlFile.mdlRoot.addChild(comments, -1, nullptr);
}
}
else
{
mdlFile.mdlRoot = mdlxTree.createCopy();
}
delete xml;
return true;
}
return false;
}
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));
}
void Project::removeDefunctExporters()
{
ValueTree exporters (projectRoot.getChildWithName (Tags::exporters));
for (;;)
{
ValueTree oldVC6Exporter (exporters.getChildWithName ("MSVC6"));
if (oldVC6Exporter.isValid())
exporters.removeChild (oldVC6Exporter, nullptr);
else
break;
}
}
void CtrlrMIDILibrary::deleteCurrentSnapshot()
{
if (getCurrentSnapshot().isValid())
{
ValueTree parent = getCurrentSnapshot().getParent();
if (parent.isValid())
{
parent.removeChild (getCurrentSnapshot(), nullptr);
currentSnapshot = ValueTree();
}
listeners.call (&CtrlrMIDILibrary::Listener::programListChanged);
}
}
void CtrlrMIDILibrary::deleteCurrentBank()
{
if (isBank (getCurrentBank()) && getRoot() != getCurrentBank())
{
ValueTree parent = getCurrentBank().getParent();
if (parent.isValid())
{
parent.removeChild (getCurrentBank(), nullptr);
setProperty (Ids::midiLibraryBank, String::empty, false);
}
listeners.call (&CtrlrMIDILibrary::Listener::programListChanged);
}
}
void ObjController::removeComment(CommentComponent* commentComp,
bool undoable, ObjectsHolder* holder)
{
if(undoable)
{
owner.getUndoManager().perform(new RemoveCommentAction(holder, commentComp, this));
}
else
{
sObjects.deselect(commentComp);
sObjects.changed(true);
const Identifier& groupName = ObjectsHelper::getObjectGroup(commentComp->getData().getType());
ValueTree mdl = owner.getMDLTree();
ValueTree subTree = mdl.getOrCreateChildWithName(groupName, nullptr);
idMgr->removeId(commentComp->getData().getType(),
commentComp->getData()[Ids::identifier].toString(), nullptr);
subTree.removeChild(commentComp->getData(), nullptr);
comments.removeObject(commentComp);
}
}
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();
}
}
void ObjController::removeObject(ObjectComponent* objComp, bool undoable, ObjectsHolder* holder)
{
if (undoable)
{
owner.getUndoManager().perform(new RemoveObjectAction(holder, objComp, this));
}
else
{
sObjects.deselect(objComp);
sObjects.changed(true);
// Get link indices attached to this object and remove them.
// TODO needs better solution
Array<int> lIndices = checkIfObjectHasLinks(objComp->getData());
// if(indices.size() > 0)
// sObjects.deselectAll();
for(int i = lIndices.size(); --i >= 0;)
{
removeLink(getLink(lIndices[i]), true, holder);
}
Array<int> aoIndices = checkIfObjectHasAudioConnections(objComp->getData());
for(int i = aoIndices.size(); --i >= 0;)
{
// remove audioouts attached to this object only if this is not an audioout
bool isAudioOut = objComp->getData().getType() == Ids::audioout;
removeAudioConnection(getAudioConnector(aoIndices[i]), !isAudioOut, holder);
}
const Identifier& groupName = ObjectsHelper::getObjectGroup(objComp->getData().getType());
ValueTree mdl = owner.getMDLTree();
ValueTree subTree = mdl.getOrCreateChildWithName(groupName, nullptr);
idMgr->removeId(objComp->getData().getType(),
objComp->getData()[Ids::identifier].toString(), nullptr);
subTree.removeChild(objComp->getData(), nullptr);
objects.removeObject(objComp);
}
}
void ProjectExporter::BuildConfiguration::removeFromExporter()
{
ValueTree configs (config.getParent());
configs.removeChild (config, project.getUndoManagerFor (configs));
}
void ProjectExporter::removePathForModule (const String& moduleID)
{
ValueTree paths (settings.getChildWithName (Ids::MODULEPATHS));
ValueTree m (paths.getChildWithProperty (Ids::ID, moduleID));
paths.removeChild (m, project.getUndoManagerFor (settings));
}
void Project::deleteConfiguration (int index)
{
ValueTree configs (getConfigurations());
configs.removeChild (index, getUndoManagerFor (getConfigurations()));
}
void Project::deleteExporter (int index)
{
ValueTree exporters (getExporters());
exporters.removeChild (index, getUndoManagerFor (exporters));
}
//==============================================================================
void AnalysisModel::removeAnalysis(ValueTree analysisTree)
{
ValueTree mainTree = analysisTree.getParent();
mainTree.removeChild(analysisTree, nullptr);
}
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;
}
