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 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);
}
bool CtrlrMIDILibrary::transactionCanHandle(const ValueTree &transactionState, const ValueTree transactionItem)
{
if (transactionState.isValid() && transactionState.hasType(Ids::trans))
{
if (luaTransInfoCbk)
{
if (luaTransInfoCbk->isValid())
{
const int ret = owner.getCtrlrLuaManager().getMethodManager().callWithRet (luaTransInfoCbk, transactionState, transactionItem);
if (ret < 0)
{
_WRN("CtrlrMIDILibrary::transactionCanHandle luaTransInfoCbk defined but failed to execute");
}
else
{
return (ret ? true : false);
}
}
}
else
{
return (transactionCanHandleType(transactionState, transactionItem));
}
}
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());
}
}
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;
}
bool AppearanceSettings::readFromXML (const XmlElement& xml)
{
if (xml.hasTagName (settings.getType().toString()))
{
const ValueTree newSettings (ValueTree::fromXml (xml));
// we'll manually copy across the new properties to the existing tree so that
// any open editors will be kept up to date..
settings.copyPropertiesFrom (newSettings, nullptr);
for (int i = settings.getNumChildren(); --i >= 0;)
{
ValueTree c (settings.getChild (i));
const ValueTree newValue (newSettings.getChildWithProperty (Ids::name, c.getProperty (Ids::name)));
if (newValue.isValid())
c.copyPropertiesFrom (newValue, nullptr);
}
return true;
}
return false;
}
void Project::updateOldStyleConfigList()
{
ValueTree deprecatedConfigsList (projectRoot.getChildWithName (Ids::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);
}
}
}
}
//==============================================================================
void ITunesLibrary::setLibraryTree (ValueTree& newTreeToUse)
{
if (! newTreeToUse.isValid())
newTreeToUse = ValueTree (MusicColumns::libraryIdentifier);
libraryTree = newTreeToUse;
}
void CtrlrManager::openPanelInternal(const ValueTree &panelTree)
{
if (panelTree.isValid())
{
addPanel(panelTree, 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);
}
}
}
/** Load plugin with settings from XML */
void ZenAutoTrimAudioProcessor::setStateInformation(const void* data, int sizeInBytes)
{
//DBG("In ZenTrimAudioProcessor::setStateInformation(data, sizeInBytes) ");
ValueTree tree = ValueTree::readFromData(data, sizeInBytes);
if (tree.isValid())
{
params->state = tree;
}
}
void CtrlrMIDILibrary::addNewTransaction (const String transactionName, ValueTree unitToAddTo)
{
ValueTree transaction = CtrlrMIDITransaction::createEmptyTransactionTree(transactionName);
if (unitToAddTo.isValid())
{
unitToAddTo.addChild (transaction, -1, nullptr);
}
}
ValueTree DrawableShape::FillAndStrokeState::getFillState (const Identifier& fillOrStrokeType)
{
ValueTree v (state.getChildWithName (fillOrStrokeType));
if (v.isValid())
return v;
setFill (fillOrStrokeType, FillType (Colours::black), nullptr, nullptr);
return getFillState (fillOrStrokeType);
}
void CtrlrMIDILibrary::setProgram (const int programMenuIndex)
{
ValueTree program = getProgramForMenuIndex (programMenuIndex);
if (program.isValid())
{
setProgram (program);
}
}
void SeaboardVisualiser::seaboardDidGetNoteOff(const juce::MidiMessage &message)
{
int channel = message.getChannel();
String childName = kChannelNo + String(channel);
ValueTree removeMe = theSeaboardData.getChildWithName(kChannelNo + String(channel));
// We check if the channel number does have a current note (if the seabaord data tree has a child tree named after the relevant channel). If so, we remove it.
if (removeMe.isValid())
{
theSeaboardData.removeChild(removeMe, 0);
}
}
void TrackInfoComponent::paint (Graphics& g)
{
const int w = getWidth();
const int h = getHeight();
const int m = 5;
g.setColour (Colours::white);
g.setFont (20);
ValueTree trackInfo (audioFilePlayer.getLibraryEntry());
if (trackInfo.isValid())
{
String infoText;
infoText << trackInfo[MusicColumns::columnNames[MusicColumns::Artist]].toString() << "\n";
infoText << trackInfo[MusicColumns::columnNames[MusicColumns::Song]].toString() << "\n";
infoText << trackInfo[MusicColumns::columnNames[MusicColumns::Album]].toString() << "\n";
infoText << trackInfo[MusicColumns::columnNames[MusicColumns::BPM]].toString();
g.setFont (16);
g.drawText (trackInfo[MusicColumns::columnNames[MusicColumns::Artist]].toString(),
m, m, w - (2 * m), 16,
Justification::centredLeft,
true);
g.setFont (20);
g.drawText (trackInfo[MusicColumns::columnNames[MusicColumns::Song]].toString(),
m, 16 + (2 * m), w - (2 * m), 20,
Justification::centredLeft,
true);
g.setColour (Colours::lightgrey);
g.setFont (12);
g.drawText (trackInfo[MusicColumns::columnNames[MusicColumns::Album]].toString(),
m, 36 + (3 * m), w - (2 * m), 12,
Justification::centredLeft,
true);
}
else
{
String displayText;
if (audioFilePlayer.getTotalLength() > 0)
displayText = "No Track Info Available";
else
displayText = "Drop Tracks Here to Begin...";
g.drawFittedText (displayText,
0, 0, w, h,
Justification (Justification::centred),
2);
}
}
//==============================================================================
ValueTree Project::getJuceConfigNode()
{
ValueTree configNode = projectRoot.getChildWithName (Tags::configGroup);
if (! configNode.isValid())
{
configNode = ValueTree (Tags::configGroup);
projectRoot.addChild (configNode, -1, 0);
}
return configNode;
}
void CtrlrLuaManager::restoreState (const ValueTree &savedState)
{
if (savedState.isValid())
{
if (savedState.getChildWithName(Ids::luaManagerMethods).isValid())
{
methodManager->restoreState (savedState.getChildWithName(Ids::luaManagerMethods));
}
}
methodManager->wrapUtilities();
}
//==============================================================================
ValueTree Project::getExporters()
{
ValueTree exporters (projectRoot.getChildWithName (Tags::exporters));
if (! exporters.isValid())
{
projectRoot.addChild (ValueTree (Tags::exporters), 0, getUndoManagerFor (projectRoot));
exporters = getExporters();
}
return exporters;
}
void SeaboardVisualiser::seaboardDidGetAftertouch(const juce::MidiMessage & message)
{
int channel = message.getChannel();
float aftertouch = message.getAfterTouchValue() / 127.f; //Normalise the aftertouch value between 0 and 1.
String childName = kChannelNo + String(channel);
ValueTree noteTree = theSeaboardData.getChildWithName(childName);
if (noteTree.isValid())
{
noteTree.setProperty(kAftertouch, aftertouch, 0);
}
}
bool Mixer::addChannel(Identifier channels_id , ValueTree channel_store)
{
// validate channels group GUI and storage
Channels* channels = getChannels(channels_id) ;
if (!channels || !channel_store.isValid()) return false ;
// create channel GUI and update mixer layout
bool was_added = channels->addChannel(channel_store) ;
if (was_added && channels != this->masterChannels) resized() ;
return was_added ;
}
bool AppearanceSettings::getColour (const String& name, Colour& result) const
{
const ValueTree colour (settings.getChildWithProperty (Ids::name, name));
if (colour.isValid())
{
result = Colour::fromString (colour [Ids::colour].toString());
return true;
}
return false;
}
void SeaboardVisualiser::seaboardDidGetPitchBend(const juce::MidiMessage & message)
{
int channel = message.getChannel();
float pitchBend = (message.getPitchWheelValue() - 8192) / 8192.f; //Normalise the pitch bend value between -1 and 1.
String childName = kChannelNo + String(channel);
ValueTree noteTree = theSeaboardData.getChildWithName(childName);
if (noteTree.isValid())
{
noteTree.setProperty(kPitchBend, pitchBend, 0);
}
}
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;
}
}
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;
}
Value AppearanceSettings::getColourValue (const String& colourName)
{
ValueTree c (settings.getChildWithProperty (Ids::name, colourName));
if (! c.isValid())
{
c = ValueTree ("COLOUR");
c.setProperty (Ids::name, colourName, nullptr);
settings.addChild (c, -1, nullptr);
}
return c.getPropertyAsValue (Ids::colour, nullptr);
}
static void getValueTreePath (ValueTree v, const ValueTree& topLevelTree, Array<int>& path)
{
while (v != topLevelTree)
{
ValueTree parent (v.getParent());
if (! parent.isValid())
break;
path.add (parent.indexOf (v));
v = parent;
}
}
AudioProcessorParameter* AudioProcessorValueTreeState::createAndAddParameter (String paramID, String paramName, String labelText,
NormalisableRange<float> r, float defaultVal,
std::function<String (float)> valueToTextFunction,
std::function<float (const String&)> textToValueFunction)
{
// All parameters must be created before giving this manager a ValueTree state!
jassert (! state.isValid());
jassert (MessageManager::getInstance()->isThisTheMessageThread());
Parameter* p = new Parameter (*this, paramID, paramName, labelText, r,
defaultVal, valueToTextFunction, textToValueFunction);
processor.addParameter (p);
return p;
}
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);
}
}
