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()); }
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 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; } }
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; }
bool SmugMug::getImages(OwnedArray<ImageItem>& images, SmugID albumId) { StringPairArray params; params.set(("AlbumID"), String(albumId.id)); params.set(("AlbumKey"), albumId.key); params.set(("Heavy"), ("1")); XmlElement* n = smugMugRequest(("smugmug.images.get"), params); if (n) { XmlElement* a = n->getChildByName(("Album")); if (a) { XmlElement* i = a->getChildByName(("Images")); if (i) { XmlElement* img = i->getChildByName(("Image")); while (img) { ImageItem* itm = new ImageItem(); itm->id.id = img->getIntAttribute(("id")); itm->id.key = img->getStringAttribute(("Key")); itm->filename = img->getStringAttribute(("FileName")); itm->caption = img->getStringAttribute(("")); itm->keywords = img->getStringAttribute(("")); itm->position = img->getIntAttribute(("Position")); itm->date = img->getStringAttribute(("Date")); itm->format = img->getStringAttribute(("Format")); itm->serial = img->getIntAttribute(("Serial")); itm->watermark = img->getBoolAttribute(("Watermark")); itm->size = img->getIntAttribute(("Size")); itm->width = img->getIntAttribute(("Width")); itm->height = img->getIntAttribute(("Height")); itm->md5sum = img->getStringAttribute(("MD5Sum")); itm->lastUpdated = img->getStringAttribute(("LastUpdated")); itm->originalURL = img->getStringAttribute(("OriginalURL")); itm->largeURL = img->getStringAttribute(("LargeURL")); itm->mediumURL = img->getStringAttribute(("MediumURL")); itm->smallURL = img->getStringAttribute(("SmallURL")); itm->tinyURL = img->getStringAttribute(("TinyURL")); itm->thumbURL = img->getStringAttribute(("ThumbURL")); itm->albumURL = img->getStringAttribute(("AlbumURL")); images.add(itm); img = img->getNextElementWithTagName(("Image")); } } } delete n; return images.size() > 0; } return false; }
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 SoloBusMixer::restoreFromXml(const XmlElement& element) { XmlElement* leftElement = element.getChildByName("Left"); if (leftElement) { m_leftFader.setValue(leftElement->getAllSubText().trim().getFloatValue()); } XmlElement* rightElement = element.getChildByName("Left"); if (rightElement) { m_rightFader.setValue(rightElement->getAllSubText().trim().getFloatValue()); } }
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; }
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; }
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; }
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; }
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; }
bool pspRoomConfigGUI::loadXmlRoomConfig(File xmlFile){ XmlDocument myDocument (xmlFile); XmlElement* mainElement = myDocument.getDocumentElement(); if (mainElement == nullptr) { AlertWindow::showMessageBoxAsync (AlertWindow::WarningIcon, "error loading room config xml file !", "", "OK"); delete mainElement; return false; } else{ if(!mainElement->hasTagName("RoomConfig")){ AlertWindow::showMessageBoxAsync (AlertWindow::WarningIcon, "xml file doesn't contain room config data", "", "OK"); delete mainElement; return false; } else{ XmlElement* roomSize = mainElement->getChildByName("roomSize"); if(roomSize){ static_cast<roomConfigSlider*>(roomDimensions[0])->setValue(roomSize->getDoubleAttribute("width")); } XmlElement* speakers = mainElement->getChildByName("speakers"); if(speakers != nullptr){ int ns = speakers->getNumChildElements(); setNumSpeakers(ns); nss->setValue(ns); cout<<endl<<speakersPosition.size(); /* for(int i=0; i<ns; i++){ static_cast<speakerPositionSlider*>(speakersPosition[3*i+0])->setValue(speakers->getChildElement(i)->getDoubleAttribute("x")); static_cast<speakerPositionSlider*>(speakersPosition[3*i+1])->setValue(speakers->getChildElement(i)->getDoubleAttribute("y")); static_cast<speakerPositionSlider*>(speakersPosition[3*i+2])->setValue(speakers->getChildElement(i)->getDoubleAttribute("z")); } */ } //delete speakers; } } delete mainElement; return true; }
virtual void setFromXML(const XmlElement& inXML) override { // DBGM("In DecibelParameter::setFromXML(inXML) "); XmlElement* thisXML = inXML.getChildByName(this->name); setValue(thisXML->getDoubleAttribute("parameterValue", -9876.5)); setDefaultValue(thisXML->getDoubleAttribute("defaultValue", -9876.5)); setShouldBeSmoothed(thisXML->getBoolAttribute("isSmoothed", false)); setMinDecibels(thisXML->getDoubleAttribute("minDecibels", -9876.5)); setMaxDecibels(thisXML->getDoubleAttribute("maxDecibels", -9876.5)); setUnityDecibels(thisXML->getDoubleAttribute("unityDecibels", -9876.5)); setMidValue(thisXML->getDoubleAttribute("midValue", -9876.5)); }
bool SmugMug::getNumberOfViews(int month, int year, OwnedArray<Views>& albums, OwnedArray<Views>& images) { StringPairArray params; params.set(("Month"), String(month)); params.set(("Year"), String(year)); XmlElement* n = smugMugRequest(("smugmug.users.getTransferStats"), params); if (n) { XmlElement* albs = n->getChildByName(("Albums")); if (albs) { XmlElement* alb = albs->getChildByName(("Album")); while (alb) { Views* v = new Views(); v->id = alb->getIntAttribute(("id")); v->views = alb->getIntAttribute(("Tiny")) + alb->getIntAttribute(("Small")) + alb->getIntAttribute(("Medium")) + alb->getIntAttribute(("Large")) + roundDoubleToInt(alb->getDoubleAttribute(("Original"))); albums.add(v); XmlElement* img = n->getChildByName(("Image")); while (img) { Views* v = new Views(); v->id = img->getIntAttribute(("id")); v->views = img->getIntAttribute(("Tiny")) + img->getIntAttribute(("Small")) + img->getIntAttribute(("Medium")) + img->getIntAttribute(("Large")) + roundDoubleToInt(img->getDoubleAttribute(("Original"))); img = img->getNextElementWithTagName(("Image")); } alb = alb->getNextElementWithTagName(("Album")); } } delete n; return true; } return false; }
int SmugMug::createCategory(const String& title) { int catId = -1; StringPairArray params; params.set(("Name"), title); XmlElement* n = smugMugRequest(("smugmug.categories.create"), params); if (n) { XmlElement* a = n->getChildByName(("Category")); if (a) catId = a->getIntAttribute(("id"), -1); delete n; } return catId; }
void pspRandomSystem::loadXml(juce::File xmlFile){ XmlDocument myDocument (xmlFile); XmlElement* mainElement = myDocument.getDocumentElement(); if (mainElement == nullptr) { AlertWindow::showMessageBoxAsync (AlertWindow::WarningIcon, "error loading randomTrajectory xml file !", "", "OK"); delete mainElement; return; } else{ if(!mainElement->hasTagName("RandomTrajectory")){ AlertWindow::showMessageBoxAsync (AlertWindow::WarningIcon, "xml file doesn't randomTrajectory data", "", "OK"); delete mainElement; return; } else{ XmlElement* params = mainElement->getChildByName("parameterValues"); if(params){ int np = params->getIntAttribute("numParticles"); changeNumParticles(np); static_cast<pspParticleSystemGUIGenericComponent*>(myGui->getGenericComponent())->getNumParticleSlider()->setValue(np); setBounds(1, params->getDoubleAttribute("lxMin")); setBounds(2, params->getDoubleAttribute("lxMax")); setBounds(3, params->getDoubleAttribute("lyMin")); setBounds(4, params->getDoubleAttribute("lyMax")); setBounds(5, params->getDoubleAttribute("lzMin")); setBounds(6, params->getDoubleAttribute("lzMax")); static_cast<pspRandomSystemSpecificGUI*>(mySpecificGui)->setSliderValues(params->getDoubleAttribute("lxMin"), params->getDoubleAttribute("lxMax"), params->getDoubleAttribute("lyMin"), params->getDoubleAttribute("lxMax"), params->getDoubleAttribute("lzMin"), params->getDoubleAttribute("lzMax")); } } } delete mainElement; }
void Equalizer::updateFromXML (XmlElement *xml) { Ppreset = xml->getIntAttribute (T("prst"), Ppreset); XmlElement* e = xml->getChildByName (T("fxpar")); if (e) { for (int n = 0; n < 128; n++) { setParameter (n, 0); XmlElement* pe = e->getChildByName (T("p") + String (n)); if (pe) setParameter (n, pe->getIntAttribute (T("v"), getParameter (n))); } } clean(); }
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; }
void PMixDocument::createNodeFromXml (XmlElement& xml, const String& newSourceCode) { PluginDescription pd; forEachXmlChildElement (xml, e) { if (pd.loadFromXml (*e)) break; } String errorMessage; AudioPluginInstance* instance = audioEngine.createPluginInstance(pd, errorMessage); jassert(instance != nullptr); if (pd.pluginFormatName == "FAUST") { FaustAudioPluginInstance* faustProc = dynamic_cast<FaustAudioPluginInstance*>(instance); faustProc->initialize(getLibraryPath(), drawPath); if (newSourceCode.length()) faustProc->setSourceCode(newSourceCode, true); // TODO: this is a bit wrong! faustProc->prepareToPlay(44100., 8192); // xml.setAttribute("numInputs", faustProc->getNumInputChannels()); // xml.setAttribute("numOutputs", faustProc->getNumOutputChannels()); ??? } AudioProcessorGraph::Node::Ptr node (audioEngine.getGraph().addNode (instance, xml.getIntAttribute ("uid"))); if (!newSourceCode.length()) { if (const XmlElement* const state = xml.getChildByName ("STATE")) { MemoryBlock m; m.fromBase64Encoding (state->getAllSubText()); node->getProcessor()->setStateInformation (m.getData(), (int) m.getSize()); } } node->properties.set ("x", xml.getDoubleAttribute ("x")); node->properties.set ("y", xml.getDoubleAttribute ("y")); node->properties.set ("uiLastX", xml.getIntAttribute ("uiLastX")); node->properties.set ("uiLastY", xml.getIntAttribute ("uiLastY")); node->properties.set ("uiStatus", xml.getIntAttribute ("uiStatus")); // presets etc for faust & plugin nodes if(!InternalPluginFormat::isInternalFormat(pd.name)) { node->properties.set ("colour", xml.getStringAttribute ("colour")); node->properties.set ("iposx", xml.getDoubleAttribute ("iposx")); node->properties.set ("iposy", xml.getDoubleAttribute ("iposy")); if (const XmlElement* const params = xml.getChildByName ("PARAMS")) { var vparams = JSON::parse(params->getAllSubText()); node->properties.set ("params", vparams); } Array<var> presetsArr; forEachXmlChildElement (xml, e) { if (e->hasTagName ("PRESET")) { DynamicObject* obj = new DynamicObject(); obj->setProperty("name", e->getStringAttribute("name")); obj->setProperty("x", e->getDoubleAttribute("x")); obj->setProperty("y", e->getDoubleAttribute("y")); obj->setProperty("radius", e->getDoubleAttribute("radius")); obj->setProperty("hidden", e->getBoolAttribute("hidden")); // obj->setProperty("distance", e->getDoubleAttribute("distance")); obj->setProperty("coeff", e->getDoubleAttribute("coeff")); var vparams = JSON::parse(e->getAllSubText()); obj->setProperty("state", vparams); obj->setProperty("uid", e->getIntAttribute("uid")); var preset = var(obj); presetsArr.add(preset); } } node->properties.set("presets", presetsArr); }
void ZenTime::setFromXML(const XmlElement& inXML) { //DBG("In ZenParameter::setFromXML(inXML) "); XmlElement* thisXML = inXML.getChildByName(paramID); setValueFromMS(thisXML->getIntAttribute("valueInMS", -987654321)); }
SmugID SmugMug::uploadFile(int queue, int index) { SmugID retval; lock.enter(); UploadFile& uf = uploadQueue[queue]->getImageFileInfo(index); lock.exit(); int64 bytesDone = 0; MD5 md5(uf.file); Time start = Time::getCurrentTime(); startTimer(LOGOUT_TIMER); String headers; String filename = uf.file.getFileName(); headers = "PUT http://upload.smugmug.com/" + URL::addEscapeChars(filename, false) + " HTTP/1.1\r\n" + "Host: upload.smugmug.com\r\n" + "Content-Length: " + String(uf.file.getSize()) + "\r\n" + "Content-MD5: " + md5.toHexString() + "\r\n" + "X-Smug-SessionID: " + sessionId + "\r\n" + "X-Smug-Version: 1.2.2\r\n" + "X-Smug-ResponseType: REST\r\n" + "X-Smug-AlbumID: " + String(uploadQueue[queue]->getAlbumId().id) + "\r\n" + "X-Smug-FileName: " + filename + "\r\n\r\n"; #ifdef JUCE_DEBUG Logger::outputDebugString(headers); #endif const char* headerUtf8 = headers.toUTF8(); StreamingSocket soc; if (soc.connect("upload.smugmug.com", 80)) { int bytesWritten = soc.write(headerUtf8, (int)strlen(headerUtf8)); if (bytesWritten == -1) { uf.status = UploadFile::Failed; return retval; } FileInputStream* fos = uf.file.createInputStream(); if (fos) { char buffer[1024 * 8]; while (!fos->isExhausted()) { int in = fos->read(buffer, sizeof(buffer)); int out = soc.write(buffer, in); startTimer(LOGOUT_TIMER); if (in != out) { delete fos; uf.status = UploadFile::Failed; return retval; } else { bytesDone += in; uf.complete = float(bytesDone)/float(uf.file.getSize()); } if (uf.status == UploadFile::Cancelled) { delete fos; return retval; } } delete fos; } else { uf.status = UploadFile::Failed; return retval; } String response; response.preallocateBytes(1024); while (1) { char buffer; int read = soc.read(&buffer, 1, true); if (read == -1) break; response += buffer; if (response.endsWith(("\r\n\r\n")) || response.endsWith(("\n\n"))) { String len = response.fromFirstOccurrenceOf(("Content-Length: "), false, true); if (len.isNotEmpty()) { // normal mode String num; int i = 0; while (CharacterFunctions::isDigit(len[i])) num += len[i++]; int bytes = num.getIntValue(); char* buffer = new char[bytes + 1]; soc.read(buffer, bytes, true); buffer[bytes] = 0; response += buffer; delete[] buffer; } else { // chunked while (1) { String line; char ch; while (!line.endsWith("\r\n")) { soc.read(&ch, 1, true); line += ch; } int sz = line.getHexValue32(); if (sz == 0) break; char* buf = new char[sz + 1]; soc.read(buf, sz, true); buf[sz] = 0; response += buf; delete buf; soc.read(&ch, 1, true); soc.read(&ch, 1, true); } } #ifdef JUCE_DEBUG Logger::outputDebugString(response); #endif soc.close(); String xml = response.fromFirstOccurrenceOf(("<?xml"), true, true); XmlDocument doc(xml); XmlElement* e = doc.getDocumentElement(); if (e) { XmlElement* image = e->getChildByName(("Image")); if (image) { int val = image->getIntAttribute(("id")); if (val >= 0) { uf.status = UploadFile::Finished; uf.complete = 1.0f; uf.url = image->getStringAttribute("URL"); Time end = Time::getCurrentTime(); RelativeTime diff = end - start; addLogEntry(("Info: ") + uf.file.getFileName() + (" uploaded in ") + String(int(diff.inSeconds())) + (" seconds [") + String(uf.file.getSize() / 1024 / diff.inSeconds(), 1) + ("KB/s]")); retval.id = val; retval.key = image->getStringAttribute(("Key")); delete e; return retval; } } delete e; } } } } uf.status = UploadFile::Failed; return retval; }