예제 #1
0
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());
}
예제 #2
0
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;
}
예제 #3
0
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;
	}
}
예제 #4
0
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;
}
예제 #5
0
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;
}
예제 #6
0
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;
}
예제 #7
0
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());
    }
}
예제 #8
0
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;
}
예제 #9
0
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;
}
예제 #10
0
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;
}
예제 #11
0
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;
}
예제 #12
0
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;
}
예제 #13
0
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;
}
예제 #14
0
    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));
    }
예제 #15
0
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;
}
예제 #16
0
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;
}
예제 #17
0
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;
}
예제 #18
0
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();
}
예제 #19
0
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;
}
예제 #20
0
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);
  }
예제 #21
0
void ZenTime::setFromXML(const XmlElement& inXML)
{
    //DBG("In ZenParameter::setFromXML(inXML) ");
    XmlElement* thisXML = inXML.getChildByName(paramID);
    setValueFromMS(thisXML->getIntAttribute("valueInMS", -987654321));
}
예제 #22
0
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;
}