void SmugMug::login(const String& username, const String& password)
{
sessionId = String::empty;
StringPairArray params;
params.set(("EmailAddress"), username);
params.set(("Password"), password);
XmlElement* n = smugMugRequest(("smugmug.login.withPassword"), params);
if (n)
{
XmlElement* l = n->getChildByName(("Login"));
if (l)
{
accountType = l->getStringAttribute(("AccountType"));
XmlElement* s = l->getChildByName(("Session"));
if (s)
{
sessionId = s->getStringAttribute(("id"));
addLogEntry(("Info: logged in session: ") + sessionId);
}
}
delete n;
}
}
XmlElement* SmugMug::smugMugRequest(const String& method, const StringPairArray& params_, bool upload)
{
StringPairArray params(params_);
params.set(("method"), method);
params.set(("APIKey"), APIKEY);
startTimer(LOGOUT_TIMER);
if (sessionId.isNotEmpty())
params.set(("SessionID"), sessionId);
URL url(upload ? UPLOAD_URL : BASE_URL);
StringArray keys = params.getAllKeys();
StringArray vals = params.getAllValues();
for (int i = 0; i < keys.size(); i++)
url = url.withParameter(keys[i], vals[i]);
XmlElement* x = url.readEntireXmlStream(upload);
#ifdef JUCE_DEBUG
Logger::outputDebugString(url.toString(true));
if (x)
Logger::outputDebugString(x->createDocument(String::empty, true));
#endif
if (x && x->getStringAttribute(("stat")) == ("fail"))
{
XmlElement* err = x->getChildByName(("err"));
if (err)
{
addLogEntry(("Error: ") + err->getStringAttribute(("msg")));
}
}
return x;
}
OnlineUnlockStatus::UnlockResult OnlineUnlockStatus::handleXmlReply (XmlElement xml)
{
UnlockResult r;
if (const XmlElement* keyNode = xml.getChildByName ("KEY"))
{
const String keyText (keyNode->getAllSubText().trim());
r.succeeded = keyText.length() > 10 && applyKeyFile (keyText);
}
else
{
r.succeeded = false;
}
if (xml.hasTagName ("MESSAGE"))
r.informativeMessage = xml.getStringAttribute ("message").trim();
if (xml.hasTagName ("ERROR"))
r.errorMessage = xml.getStringAttribute ("error").trim();
if (xml.getStringAttribute ("url").isNotEmpty())
r.urlToLaunch = xml.getStringAttribute ("url").trim();
if (r.errorMessage.isEmpty() && r.informativeMessage.isEmpty() && r.urlToLaunch.isEmpty() && ! r.succeeded)
r.errorMessage = TRANS ("Unexpected or corrupted reply from XYZ").replace ("XYZ", getWebsiteName()) + "...\n\n"
+ TRANS("Please try again in a few minutes, and contact us for support if this message appears again.");
return r;
}
void CDPlayer::restoreFromXml(const XmlElement& element, const File& /*projectDirectory*/)
{
setColor(Colour::fromString(element.getStringAttribute("color", "0xffffffff")));
repaint();
XmlElement* boundsXml = element.getChildByName("Bounds");
if (boundsXml)
{
String x = boundsXml->getStringAttribute("x", "0");
String y = boundsXml->getStringAttribute("y", "0");
String width = boundsXml->getStringAttribute("width", "150");
String height = boundsXml->getStringAttribute("height", "150");
getParentComponent()->setBounds(x.getIntValue(), y.getIntValue(), width.getIntValue(), height.getIntValue());
}
else
{
XmlElement* mdiDocumentPosXml = element.getChildByName("MdiDocumentPos");
if (mdiDocumentPosXml->getNumChildElements() > 0 && mdiDocumentPosXml->getFirstChildElement()->isTextElement())
{
getProperties().set("mdiDocumentPos_", mdiDocumentPosXml->getFirstChildElement()->getText());
}
}
XmlElement* nameXml = element.getChildByName("Name");
setName(nameXml->getAllSubText().trim());
XmlElement* driveXml = element.getChildByName("Drive");
m_availableCDsComboBox.selectDrive(driveXml->getAllSubText().trim());
}
void RelativePositionedRectangle::restoreFromXml (const XmlElement& e,
const RelativePositionedRectangle& defaultPos)
{
rect = PositionedRectangle (e.getStringAttribute ("pos", defaultPos.rect.toString()));
relativeToX = e.getStringAttribute ("posRelativeX", String::toHexString (defaultPos.relativeToX)).getHexValue64();
relativeToY = e.getStringAttribute ("posRelativeY", String::toHexString (defaultPos.relativeToY)).getHexValue64();
relativeToW = e.getStringAttribute ("posRelativeW", String::toHexString (defaultPos.relativeToW)).getHexValue64();
relativeToH = e.getStringAttribute ("posRelativeH", String::toHexString (defaultPos.relativeToH)).getHexValue64();
}
bool ColouredElement::loadColourAttributes (const XmlElement& xml)
{
fillType.restoreFromString (xml.getStringAttribute ("fill", String::empty));
isStrokePresent = showOutline && xml.getBoolAttribute ("hasStroke", false);
strokeType.restoreFromString (xml.getStringAttribute ("stroke", String::empty));
strokeType.fill.restoreFromString (xml.getStringAttribute ("strokeColour", String::empty));
return true;
}
bool SmugMug::getAlbumList(OwnedArray<Album>& albums)
{
StringPairArray params;
XmlElement* n = smugMugRequest(("smugmug.albums.get"), params);
if (n)
{
XmlElement* a = n->getChildByName(("Albums"));
if (a)
{
XmlElement* alb = a->getChildByName(("Album"));
while (alb)
{
Album* album = new Album();
album->id.id = alb->getIntAttribute(("id"));
album->id.key = alb->getStringAttribute(("Key"));
album->title = alb->getStringAttribute(("Title"));
XmlElement* cat = alb->getChildByName(("Category"));
if (cat)
{
album->category = cat->getStringAttribute(("Name"));
album->categoryId = cat->getIntAttribute(("id"));
}
else
{
album->category = String::empty;
album->categoryId = -1;
}
XmlElement* subcat = alb->getChildByName(("SubCategory"));
if (subcat)
{
album->subCategory = subcat->getStringAttribute(("Name"));
album->subCategoryId = subcat->getIntAttribute(("id"));
}
else
{
album->subCategory = String::empty;
album->subCategoryId = -1;
}
albums.add(album);
alb = alb->getNextElementWithTagName(("Album"));
}
}
delete n;
return true;
}
return false;
}
void StoredSettings::initDefaultPropertiesFile()
{
XmlDocument defaultValuesXml(String::createStringFromData(BinaryData::default_values_xml,
BinaryData::default_values_xmlSize));
ScopedPointer<XmlElement> elem(defaultValuesXml.getDocumentElement());
if (getDefaultValues().getAllProperties().size() != elem->getNumChildElements())
{
for (int i = 0; i < elem->getNumChildElements(); ++i)
{
XmlElement* c = elem->getChildElement(i);
getDefaultValues().setValue(c->getStringAttribute("name"), c->getStringAttribute("val"));
}
}
}
bool SmugMug::getCategoryList(OwnedArray<Category>& categories)
{
StringPairArray params;
XmlElement* n = smugMugRequest(("smugmug.categories.get"), params);
if (n)
{
XmlElement* c = n->getChildByName(("Categories"));
if (c)
{
XmlElement* cat = c->getChildByName(("Category"));
while (cat)
{
Category* category = new Category();
category->id = cat->getIntAttribute(("id"));
category->title = cat->getStringAttribute(("Name"));
categories.add(category);
cat = cat->getNextElementWithTagName(("Category"));
}
}
delete n;
return true;
}
return false;
}
SmugID SmugMug::createAlbum(const String& title, const int categoryId, const StringPairArray& albumFlags)
{
SmugID newAlbum;
newAlbum.id = -1;
StringPairArray params(albumFlags);
params.set(("Title"), title);
params.set(("CategoryID"), String(categoryId));
XmlElement* n = smugMugRequest(("smugmug.albums.create"), params);
if (n)
{
XmlElement* a = n->getChildByName(("Album"));
if (a)
{
newAlbum.id = a->getIntAttribute(("id"), -1);
newAlbum.key = a->getStringAttribute(("Key"));
}
if (newAlbum.id != -1)
addLogEntry(("Info: album created: ") + title);
delete n;
}
return newAlbum;
}
void XmlParser::readConfig()
{
XmlDocument* xmlConfigDoc = new XmlDocument(File(File::getCurrentWorkingDirectory().getChildFile(configFile)));
XmlElement* xmlConfigElem = xmlConfigDoc->getDocumentElement();
if (xmlConfigElem != NULL)
{
XmlElement* pictures = xmlConfigElem->getChildByName(T("pictures"));
if (pictures != NULL)
{
if (pictures->hasAttribute(T("path")))
{
m_picturePath = pictures->getStringAttribute(T("path"));
}
else
{
LOG_ERROR(T("Element \"pictures\" is incomplete"));
}
}
else
{
LOG_ERROR(T("Element \"pictures\" not found"));
}
delete xmlConfigElem;
}
else
{
LOG_ERROR((T("XML load failed: %ls"), (const juce_wchar*)xmlConfigDoc->getLastParseError()));
}
delete xmlConfigDoc;
}
bool SmugMug::getSubCategoryList(OwnedArray<SubCategory>& subCategories)
{
StringPairArray params;
XmlElement* n = smugMugRequest(("smugmug.subcategories.getAll"), params);
if (n)
{
XmlElement* c = n->getChildByName(("SubCategories"));
if (c)
{
XmlElement* subCat = c->getChildByName(("SubCategory"));
while (subCat)
{
SubCategory* subCategory = new SubCategory();
subCategory->id = subCat->getIntAttribute(("id"));
subCategory->title = subCat->getStringAttribute(("Name"));
XmlElement* cat = subCat->getChildByName(("Category"));
if (cat)
subCategory->parentId = cat->getIntAttribute(("id"));
subCategories.add(subCategory);
subCat = subCat->getNextElementWithTagName(("SubCategory"));
}
}
delete n;
return true;
}
return false;
}
void StoredSettings::initExporters()
{
if(getExporters().getAllProperties().size() == 0)
{
XmlDocument xml(String::createStringFromData(BinaryData::default_exporters_xml,
BinaryData::default_exporters_xmlSize));
ScopedPointer<XmlElement> elem(xml.getDocumentElement());
for (int i = 0; i < elem->getNumChildElements(); ++i)
{
XmlElement* c = elem->getChildElement(i);
getExporters().setValue(c->getStringAttribute("name"), c->getStringAttribute("val"));
}
String currentExporter = getExporters().getAllProperties().getAllKeys()[0];
setCurrentExporter(currentExporter);
}
}
static StringArray getMachineNumbers (XmlElement xml, StringRef attributeName)
{
StringArray numbers;
numbers.addTokens (xml.getStringAttribute (attributeName), ",; ", StringRef());
numbers.trim();
numbers.removeEmptyStrings();
return numbers;
}
void CommandTableModel::buildFromXml(XmlElement *root)
{
if (root->getTagName().compare("settings") != 0)
return;
removeAllRows();
XmlElement* setting = root->getFirstChildElement();
while ((setting) && (m_commandMap))
{
if (setting->hasAttribute("controller"))
{
MIDI_Message cc(setting->getIntAttribute("channel"), setting->getIntAttribute("controller"), true);
addRow(cc.channel, cc.controller, true);
// older versions of MIDI2LR stored the index of the string, so we should attempt to parse this as well
if (setting->getIntAttribute("command", -1) != -1)
{
m_commandMap->addCommandforMessage(setting->getIntAttribute("command"), cc);
}
else
{
m_commandMap->addCommandforMessage(setting->getStringAttribute("command_string"), cc);
}
}
else if (setting->hasAttribute("note"))
{
MIDI_Message note(setting->getIntAttribute("channel"), setting->getIntAttribute("note"), false);
addRow(note.channel, note.pitch, false);
// older versions of MIDI2LR stored the index of the string, so we should attempt to parse this as well
if (setting->getIntAttribute("command", -1) != -1)
{
m_commandMap->addCommandforMessage(setting->getIntAttribute("command"), note);
}
else
{
m_commandMap->addCommandforMessage(setting->getStringAttribute("command_string"), note);
}
}
setting = setting->getNextElement();
}
}
void ChannelRemappingAudioSource::restoreFromXml (const XmlElement& e)
{
if (e.hasTagName ("MAPPINGS"))
{
const ScopedLock sl (lock);
clearAllMappings();
StringArray ins, outs;
ins.addTokens (e.getStringAttribute ("inputs"), false);
outs.addTokens (e.getStringAttribute ("outputs"), false);
for (int i = 0; i < ins.size(); ++i)
remappedInputs.add (ins[i].getIntValue());
for (int i = 0; i < outs.size(); ++i)
remappedOutputs.add (outs[i].getIntValue());
}
}
bool SmugMug::getImageUrls(SmugID id, ImageUrls& urls)
{
StringPairArray params;
params.set(("ImageID"), String(id.id));
params.set(("ImageKey"), id.key);
params.set(("Password"), "");
XmlElement* n = smugMugRequest(("smugmug.images.getURLs"), params);
if (n)
{
XmlElement* img = n->getChildByName(("Image"));
if (img)
{
urls.originalURL = img->getStringAttribute(("OriginalURL"));
urls.largeURL = img->getStringAttribute(("LargeURL"));
urls.mediumURL = img->getStringAttribute(("MediumURL"));
urls.smallURL = img->getStringAttribute(("SmallURL"));
urls.tinyURL = img->getStringAttribute(("TinyURL"));
urls.thumbURL = img->getStringAttribute(("ThumbURL"));
urls.albumURL = img->getStringAttribute(("AlbumURL"));
}
delete n;
return true;
}
return false;
}
void FaustgenFactory::setStateInformation (XmlElement& xml)
{
String faustgen_version = xml.getStringAttribute("version");
String sourcecode;
String bitcode;
if (faustgen_version == String::empty)
{
LOG("Cannot read \"version\" key, so ignore bitcode, force recompilation and use default compileoptions");
goto default_sourcecode;
}
else if (faustgen_version != FAUSTGEN_VERSION)
{
String logStr;
logStr << "Older version of faustgen (" << FAUSTGEN_VERSION << "versus " << faustgen_version << "), so ignore bitcode, force recompilation and use default compileoptions";
LOG(logStr);
goto read_sourcecode;
}
bitcode = xml.getStringAttribute("bitcode");
if (bitcode != String::empty)
{
fBitCode = bitcode;
}
read_sourcecode:
sourcecode = xml.getStringAttribute("sourcecode");
if (sourcecode != String::empty)
{
fSourceCode = sourcecode;
return;
}
default_sourcecode:
fSourceCode = DEFAULT_CODE;
}
JucerDocument* loadDocumentFromFile (const File& f, const bool showErrorMessage)
{
File file (f);
if (file == File::nonexistent && showErrorMessage)
{
FileChooser fc ("Open a Jucer C++ file...",
StoredSettings::getInstance()->recentFiles.getFile (0),
"*.cpp");
if (! fc.browseForFileToOpen())
return 0;
file = fc.getResult();
}
XmlElement* xml = JucerDocument::pullMetaDataFromCppFile (file.loadFileAsString());
if (xml == 0 || ! xml->hasTagName (JucerDocument::jucerCompXmlTag))
{
if (file != File::nonexistent && showErrorMessage)
AlertWindow::showMessageBox (AlertWindow::WarningIcon,
TRANS("Failed to open file..."),
TRANS("This wasn't a valid Jucer .cpp file..."));
delete xml;
return 0;
}
const String docType (xml->getStringAttribute ("documentType"));
delete xml;
// (reverse order so ComponentDocument is default last-case)
for (int i = numDocumentTypes; --i >= 0;)
{
if (docType.equalsIgnoreCase (documentTypeNames[i]) || i == 0)
{
JucerDocument* doc = createNewDocument (i);
if (doc->loadFrom (file, showErrorMessage))
return doc;
delete doc;
break;
}
}
return 0;
}
bool PluginDescription::loadFromXml (const XmlElement& xml)
{
if (xml.hasTagName ("PLUGIN"))
{
name = xml.getStringAttribute ("name");
descriptiveName = xml.getStringAttribute ("descriptiveName", name);
pluginFormatName = xml.getStringAttribute ("format");
category = xml.getStringAttribute ("category");
manufacturerName = xml.getStringAttribute ("manufacturer");
version = xml.getStringAttribute ("version");
fileOrIdentifier = xml.getStringAttribute ("file");
uid = xml.getStringAttribute ("uid").getHexValue32();
isInstrument = xml.getBoolAttribute ("isInstrument", false);
lastFileModTime = Time (xml.getStringAttribute ("fileTime").getHexValue64());
lastInfoUpdateTime = Time (xml.getStringAttribute ("infoUpdateTime").getHexValue64());
numInputChannels = xml.getIntAttribute ("numInputs");
numOutputChannels = xml.getIntAttribute ("numOutputs");
hasSharedContainer = xml.getBoolAttribute ("isShell", false);
return true;
}
return false;
}
/// Load parameter value from XML.
///
/// @param xmlDocument XML document to load from
///
void ParString::loadFromXml(XmlElement *xmlDocument)
{
// get parameter's element from XML document
XmlElement *xmlParameter = xmlDocument->getChildByName(getTagName());
// parameter's element found
if (xmlParameter)
{
// get stored value from attribute "value" (or use empty string)
String newValue = xmlParameter->getStringAttribute("value", String());
// update value
setText(newValue);
}
}
bool SmugMug::deleteSubCategory(int subCategory)
{
StringPairArray params;
params.set(("SubCategoryID"), String(subCategory));
XmlElement* n = smugMugRequest(("smugmug.subcategories.delete"), params);
if (n)
{
if (n->getTagName() == ("rsp") && n->getStringAttribute(("stat")) == ("ok"))
{
delete n;
return true;
}
delete n;
}
return false;
}
bool SmugMug::deleteAlbum(SmugID album)
{
StringPairArray params;
params.set(("AlbumID"), String(album.id));
XmlElement* n = smugMugRequest(("smugmug.albums.delete"), params);
if (n)
{
if (n->getTagName() == ("rsp") && n->getStringAttribute(("stat")) == ("ok"))
{
delete n;
return true;
}
delete n;
}
return false;
}
bool SmugMug::deleteImage(SmugID image)
{
StringPairArray params;
params.set(("ImageID"), String(image.id));
XmlElement* n = smugMugRequest(("smugmug.images.delete"), params);
if (n)
{
if (n->getTagName() == ("rsp") && n->getStringAttribute(("stat")) == ("ok"))
{
delete n;
return true;
}
delete n;
}
return false;
}
static KeyFileData getDataFromKeyFile (XmlElement xml)
{
KeyFileData data;
data.licensee = getLicensee (xml);
data.email = getEmail (xml);
data.appID = getAppID (xml);
if (xml.hasAttribute ("expiryTime") && xml.hasAttribute ("expiring_mach"))
{
data.keyFileExpires = true;
data.machineNumbers.addArray (getMachineNumbers (xml, "expiring_mach"));
data.expiryTime = Time (xml.getStringAttribute ("expiryTime").getHexValue64());
}
else
{
data.keyFileExpires = false;
data.machineNumbers.addArray (getMachineNumbers (xml, "mach"));
}
return data;
}
bool JucerDocument::loadFromXml (const XmlElement& xml)
{
if (xml.hasTagName (jucerCompXmlTag)
&& getTypeName().equalsIgnoreCase (xml.getStringAttribute ("documentType")))
{
className = xml.getStringAttribute ("className", defaultClassName);
templateFile = xml.getStringAttribute ("template", String::empty);
componentName = xml.getStringAttribute ("componentName", String::empty);
parentClasses = xml.getStringAttribute ("parentClasses", defaultParentClasses);
constructorParams = xml.getStringAttribute ("constructorParams", String::empty);
variableInitialisers = xml.getStringAttribute ("variableInitialisers", String::empty);
fixedSize = xml.getBoolAttribute ("fixedSize", false);
initialWidth = xml.getIntAttribute ("initialWidth", 300);
initialHeight = xml.getIntAttribute ("initialHeight", 200);
snapGridPixels = xml.getIntAttribute ("snapPixels", snapGridPixels);
snapActive = xml.getBoolAttribute ("snapActive", snapActive);
snapShown = xml.getBoolAttribute ("snapShown", snapShown);
componentOverlayOpacity = (float) xml.getDoubleAttribute ("overlayOpacity", 0.0);
activeExtraMethods.clear();
if (XmlElement* const methods = xml.getChildByName ("METHODS"))
forEachXmlChildElementWithTagName (*methods, e, "METHOD")
activeExtraMethods.addIfNotAlreadyThere (e->getStringAttribute ("name"));
activeExtraMethods.trim();
activeExtraMethods.removeEmptyStrings();
changed();
getUndoManager().clearUndoHistory();
return true;
}
return false;
}
bool ComponentTypeHandler::restoreFromXml (const XmlElement& xml,
Component* comp,
const ComponentLayout* layout)
{
jassert (xml.hasTagName (getXmlTagName()));
if (! xml.hasTagName (getXmlTagName()))
return false;
comp->setName (xml.getStringAttribute ("name", comp->getName()));
setComponentId (comp, xml.getStringAttribute ("id").getHexValue64());
comp->getProperties().set ("memberName", xml.getStringAttribute ("memberName"));
comp->getProperties().set ("virtualName", xml.getStringAttribute ("virtualName"));
comp->setExplicitFocusOrder (xml.getIntAttribute ("explicitFocusOrder"));
RelativePositionedRectangle currentPos (getComponentPosition (comp));
currentPos.updateFromComponent (*comp, layout);
RelativePositionedRectangle rpr;
rpr.restoreFromXml (xml, currentPos);
jassert (layout != 0);
setComponentPosition (comp, rpr, layout);
SettableTooltipClient* const ttc = dynamic_cast <SettableTooltipClient*> (comp);
if (ttc != 0)
ttc->setTooltip (xml.getStringAttribute ("tooltip"));
for (int i = 0; i < colours.size(); ++i)
{
const String col (xml.getStringAttribute (colours[i]->xmlTagName, String::empty));
if (col.isNotEmpty())
{
comp->setColour (colours[i]->colourId,
Colour (col.getHexValue32()));
}
}
return true;
}
String AudioDeviceManager::initialiseFromXML (const XmlElement& xml,
const bool selectDefaultDeviceOnFailure,
const String& preferredDefaultDeviceName,
const AudioDeviceSetup* preferredSetupOptions)
{
lastExplicitSettings = new XmlElement (xml);
String error;
AudioDeviceSetup setup;
if (preferredSetupOptions != nullptr)
setup = *preferredSetupOptions;
if (xml.getStringAttribute ("audioDeviceName").isNotEmpty())
{
setup.inputDeviceName = setup.outputDeviceName
= xml.getStringAttribute ("audioDeviceName");
}
else
{
setup.inputDeviceName = xml.getStringAttribute ("audioInputDeviceName");
setup.outputDeviceName = xml.getStringAttribute ("audioOutputDeviceName");
}
currentDeviceType = xml.getStringAttribute ("deviceType");
if (findType (currentDeviceType) == nullptr)
{
if (AudioIODeviceType* const type = findType (setup.inputDeviceName, setup.outputDeviceName))
currentDeviceType = type->getTypeName();
else if (availableDeviceTypes.size() > 0)
currentDeviceType = availableDeviceTypes.getUnchecked(0)->getTypeName();
}
setup.bufferSize = xml.getIntAttribute ("audioDeviceBufferSize", setup.bufferSize);
setup.sampleRate = xml.getDoubleAttribute ("audioDeviceRate", setup.sampleRate);
setup.inputChannels .parseString (xml.getStringAttribute ("audioDeviceInChans", "11"), 2);
setup.outputChannels.parseString (xml.getStringAttribute ("audioDeviceOutChans", "11"), 2);
setup.useDefaultInputChannels = ! xml.hasAttribute ("audioDeviceInChans");
setup.useDefaultOutputChannels = ! xml.hasAttribute ("audioDeviceOutChans");
error = setAudioDeviceSetup (setup, true);
midiInsFromXml.clear();
forEachXmlChildElementWithTagName (xml, c, "MIDIINPUT")
midiInsFromXml.add (c->getStringAttribute ("name"));
const StringArray allMidiIns (MidiInput::getDevices());
for (int i = allMidiIns.size(); --i >= 0;)
setMidiInputEnabled (allMidiIns[i], midiInsFromXml.contains (allMidiIns[i]));
if (error.isNotEmpty() && selectDefaultDeviceOnFailure)
error = initialise (numInputChansNeeded, numOutputChansNeeded,
nullptr, false, preferredDefaultDeviceName);
setDefaultMidiOutput (xml.getStringAttribute ("defaultMidiOutput"));
return error;
}
void MLPluginProcessor::setStateFromXML(const XmlElement& xmlState, bool setViewAttributes)
{
if (!(xmlState.hasTagName (JucePlugin_Name))) return;
if (!(mEngine.getCompileStatus() == MLProc::OK)) return; // TODO revisit need to compile first
// getCallbackLock() is in juce_AudioProcessor
// process lock is a quick fix. it is here to prevent doParams() from getting called in
// process() methods and thereby setting mParamsChanged to false before the real changes take place.
// A better alternative would be a lock-free queue of parameter changes.
const ScopedLock sl (getCallbackLock());
// only the differences between default parameters and the program state are saved in a program,
// so the first step is to set the default parameters.
setDefaultParameters();
// get program version of saved state
unsigned blobVersion = xmlState.getIntAttribute ("pluginVersion");
unsigned pluginVersion = JucePlugin_VersionCode;
if (blobVersion > pluginVersion)
{
// TODO show error to user
MLError() << "MLPluginProcessor::setStateFromXML: saved program version is newer than plugin version!\n";
return;
}
// try to load scale if a scale attribute exists
// TODO auto save all state including this
const String scaleDir = xmlState.getStringAttribute ("scaleDir"); // look for old-style dir attribute
const String scaleName = xmlState.getStringAttribute ("scaleName");
String fullName;
if(scaleName != String::empty)
{
fullName = scaleName;
if(scaleDir != String::empty)
{
fullName = scaleDir + String("/") + fullName + ".scl";
}
}
else
{
fullName = "12-equal";
}
std::string fullScaleName(fullName.toUTF8());
setProperty("key_scale", fullScaleName);
bool loaded = false;
// look for scale under full name with path
if(fullScaleName != std::string())
{
const MLFilePtr f = mScaleFiles->getFileByName(fullScaleName);
if(f != MLFilePtr())
{
loadScale(f->mFile);
loaded = true;
}
}
if(!loaded)
{
loadDefaultScale();
}
// get preset name saved in blob. when saving from AU host, name will also be set from RestoreState().
const String presetName = xmlState.getStringAttribute ("presetName");
setProperty("preset", std::string(presetName.toUTF8()));
/*
debug() << "MLPluginProcessor: setStateFromXML: loading program " << presetName << ", version " << std::hex << blobVersion << std::dec << "\n";
MemoryOutputStream myStream;
xmlState->writeToStream (myStream, "");
debug() << myStream.toString();
*/
/*
setCurrentPresetName(presetName.toUTF8());
setCurrentPresetDir(presetDir.toUTF8());
*/
// get plugin-specific translation table for updating older versions of data
std::map<MLSymbol, MLSymbol> translationTable;
// TODO move this into Aalto!
// make translation tables based on program version.
//
if (blobVersion <= 0x00010120)
{
// translate seq parameters
for(unsigned n=0; n<16; ++n)
{
std::stringstream pName;
std::stringstream pName2;
pName << "seq_value" << n;
pName2 << "seq_pulse" << n;
MLSymbol oldSym(pName.str());
MLSymbol newSym = MLSymbol("seq_value#").withFinalNumber(n);
MLSymbol oldSym2(pName2.str());
MLSymbol newSym2 = MLSymbol("seq_pulse#").withFinalNumber(n);
translationTable[oldSym] = newSym;
translationTable[oldSym2] = newSym2;
}
}
if (blobVersion <= 0x00010200)
{
MLSymbol oldSym = MLSymbol("seq_value");
MLSymbol newSym = MLSymbol("seq_value").withFinalNumber(0);
MLSymbol oldSym2 = MLSymbol("seq_pulse");
MLSymbol newSym2 = MLSymbol("seq_pulse").withFinalNumber(0);
translationTable[oldSym] = newSym;
translationTable[oldSym2] = newSym2;
// translate seq parameters
for(unsigned n=1; n<16; ++n)
{
oldSym = MLSymbol("seq_value#").withFinalNumber(n);
newSym = MLSymbol("seq_value").withFinalNumber(n);
oldSym2 = MLSymbol("seq_pulse#").withFinalNumber(n);
newSym2 = MLSymbol("seq_pulse").withFinalNumber(n);
translationTable[oldSym] = newSym;
translationTable[oldSym2] = newSym2;
}
}
// get params from xml
const unsigned numAttrs = xmlState.getNumAttributes();
String patcherInputStr ("patcher_input_");
for(unsigned i=0; i<numAttrs; ++i)
{
// get name / value pair.
const String& attrName = xmlState.getAttributeName(i);
const MLParamValue paramVal = xmlState.getDoubleAttribute(attrName);
// if not a patcher input setting,
if (!attrName.contains(patcherInputStr))
{
// see if we have this named parameter in our engine.
MLSymbol paramSym = XMLAttrToSymbol(attrName);
const int pIdx = getParameterIndex(paramSym);
if (pIdx >= 0)
{
// debug() << "setStateFromXML: <" << paramSym << " = " << paramVal << ">\n";
setPropertyImmediate(paramSym, paramVal);
}
else // try finding a match through translation table.
{
//debug() << "Looking for parameter " << paramSym << " in table...\n";
std::map<MLSymbol, MLSymbol>::iterator it;
it = translationTable.find(paramSym);
if (it != translationTable.end())
{
const MLSymbol newSym = translationTable[paramSym];
const int pNewIdx = getParameterIndex(newSym);
if (pNewIdx >= 0)
{
//debug() << "translated parameter to " << newSym << " .\n";
setPropertyImmediate(newSym, paramVal);
}
else
{
MLError() << "MLPluginProcessor::setStateFromXML: no such parameter! \n";
}
}
else
{
// fail silently on unfound params, because we have deprecated some but they may still
// be around in old presets.
//debug() << "MLPluginProcessor::setStateFromXML: parameter " << paramSym << " not found!\n";
}
}
}
}
// get editor state from XML
if(setViewAttributes)
{
int x = xmlState.getIntAttribute("editor_x");
int y = xmlState.getIntAttribute("editor_y");
int width = xmlState.getIntAttribute("editor_width");
int height = xmlState.getIntAttribute("editor_height");
mEditorRect = MLRect(x, y, width, height);
mEditorNumbersOn = xmlState.getIntAttribute("editor_num", 1);
mEditorAnimationsOn = xmlState.getIntAttribute("editor_anim", 1);
}
}
static String getAppID (const XmlElement& xml) { return xml.getStringAttribute ("app"); }
