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