Diff: dataformfactory.cpp - dataformfactory.cpp

	dataformfactory.cpp	dataformfactory.cpp

	skipping to change at line 29	skipping to change at line 29
	**	**
	** You should have received a copy of the GNU General Public License	** You should have received a copy of the GNU General Public License
	** along with this program. If not, see http://www.gnu.org/licenses/.	** along with this program. If not, see http://www.gnu.org/licenses/.
	** $JREEN_END_LICENSE$	** $JREEN_END_LICENSE$
	**	**
	*************************************************************************** */	*************************************************************************** */

	#include "dataformfactory_p.h"	#include "dataformfactory_p.h"
	#include "jstrings.h"	#include "jstrings.h"
	#include <QXmlStreamWriter>	#include <QXmlStreamWriter>

		#include <QSize>
		#include <QUrl>
	#include "util.h"	#include "util.h"

	#include "multimediadatafactory_p.h"
	#include "logger.h"	#include "logger.h"
	#define NS_DATAFORM QLatin1String("jabber:x:data")	#define NS_DATAFORM QLatin1String("jabber:x:data")

		#define NS_MEDIA QLatin1String("urn:xmpp:media-element")

	namespace Jreen {	namespace Jreen {

	using namespace Util;	using namespace Util;

	class DataFormOptionParser : XmlStreamFactory<const QPair<QString, QString> >	class DataFormOptionParser : XmlStreamFactory<const QPair<QString, QString> >
	{	{
	public:	public:
	DataFormOptionParser()	DataFormOptionParser()
	{	{

	skipping to change at line 113	skipping to change at line 115
	m_label.clear();	m_label.clear();
	m_value.clear();	m_value.clear();
	m_atValue = 0;	m_atValue = 0;
	}	}
	int m_depth : 31;	int m_depth : 31;
	int m_atValue : 1;	int m_atValue : 1;
	QString m_label;	QString m_label;
	QString m_value;	QString m_value;
	};	};


		class DataFormMediaParser : public XmlStreamFactory<DataFormMedia>
		{
		public:
		DataFormMediaParser() : m_depth(0), m_state(AtNowhere)
		{
		}

		virtual ~DataFormMediaParser()
		{
		}

		virtual bool canParse(const QStringRef &name, const QStringRef &uri,
		const QXmlStreamAttributes
		&attributes)
		{
		Q_UNUSED(attributes);
		return name == QLatin1String("media") && uri == NS_MEDIA;
		}
		virtual void handleStartElement(const QStringRef &name, const QStrin
		gRef &uri,
		cons
		t QXmlStreamAttributes &attributes)
		{
		Q_UNUSED(name);
		Q_UNUSED(uri);
		m_depth++;

		if(m_depth == 1) {
		m_state = AtNowhere;
		m_media = DataFormMedia::Ptr::create();
		} else if (m_depth == 2 && name == QLatin1String("uri")) {
		m_state = AtUri;
		m_uriType = attributes.value(QLatin1String("type")).
		toString();
		}
		}
		virtual void handleEndElement(const QStringRef &name, const QStringR
		ef &uri)
		{
		Q_UNUSED(name);
		Q_UNUSED(uri);
		if (m_depth == 2)
		m_state = AtNowhere;
		m_depth--;
		}
		virtual void handleCharacterData(const QStringRef &text)
		{
		if(m_depth == 2 && m_state == AtUri) {
		m_media->appendUri(text.toString(), m_uriType);
		}
		}
		virtual void serialize(DataFormMedia media, QXmlStreamWriter write
		r)
		{
		writer->writeStartElement(QLatin1String("media"));
		const QSize size = media->size();
		if (size.width() >= 0)
		writer->writeAttribute(QLatin1String("width"), QStri
		ng::number(size.width()));
		if (size.height() >= 0)
		writer->writeAttribute(QLatin1String("height"), QStr
		ing::number(size.height()));
		writer->writeDefaultNamespace(NS_MEDIA);
		foreach (const DataFormMedia::Uri &uri, media->uries()) {
		writer->writeStartElement(QLatin1String("uri"));
		writer->writeAttribute(QLatin1String("type"), uri.ty
		pe());
		writer->writeCharacters(uri.url().toString());
		writer->writeEndElement();
		}
		writer->writeEndElement();
		}
		DataFormMedia::Ptr create()
		{
		DataFormMedia::Ptr result;
		qSwap(result, m_media);
		return result;
		}

		private:
		int m_depth;
		enum State {
		AtNowhere,
		AtUri
		} m_state;
		QString m_uriType;
		DataFormMedia::Ptr m_media;
		};

	static const char* datafield_types[] = {	static const char* datafield_types[] = {
	"boolean",	"boolean",
	"fixed",	"fixed",
	"hidden",	"hidden",
	"jid-multi",	"jid-multi",
	"jid-single",	"jid-single",
	"list-multi",	"list-multi",
	"list-single",	"list-single",
	"text-multi",	"text-multi",
	"text-private",	"text-private",

	"text-single"	"text-single",
		""
	};	};

	class DataFormFieldParser : XmlStreamFactory<DataFormField>	class DataFormFieldParser : XmlStreamFactory<DataFormField>
	{	{
	public:	public:
	DataFormFieldParser()	DataFormFieldParser()
	{	{
	m_depth = 0;	m_depth = 0;
	m_state = AtNowhere;	m_state = AtNowhere;
	}	}

	skipping to change at line 158	skipping to change at line 241
	m_depth++;	m_depth++;
	if(m_depth == 1) {	if(m_depth == 1) {
	m_type = strToEnum<DataFormField::Type>(attributes.v alue(QLatin1String("type")),datafield_types);	m_type = strToEnum<DataFormField::Type>(attributes.v alue(QLatin1String("type")),datafield_types);
	m_var = attributes.value(QLatin1String("var")).toStr ing();	m_var = attributes.value(QLatin1String("var")).toStr ing();
	m_label = attributes.value(QLatin1String("label")).t oString();	m_label = attributes.value(QLatin1String("label")).t oString();
	} else if (m_depth == 2) {	} else if (m_depth == 2) {
	if(name == QLatin1String("value")) {	if(name == QLatin1String("value")) {
	m_state = AtValue;	m_state = AtValue;
	} else if(m_optionParser.canParse(name,uri,attribute s)) {	} else if(m_optionParser.canParse(name,uri,attribute s)) {
	m_state = AtOption;	m_state = AtOption;

		} else if (m_mediaParser.canParse(name, uri, attribu
		tes)) {
		m_state = AtMedia;
	} else if(name == QLatin1String("required")) {	} else if(name == QLatin1String("required")) {
	m_state = AtRequied;	m_state = AtRequied;
	m_required = true;	m_required = true;
	} else {	} else {
	m_state = AtNowhere;	m_state = AtNowhere;
	}	}
	}	}
	if(m_state == AtOption)	if(m_state == AtOption)
	m_optionParser.handleStartElement(name,uri,attribute s);	m_optionParser.handleStartElement(name,uri,attribute s);

		else if(m_state == AtMedia)
		m_mediaParser.handleStartElement(name, uri, attribut
		es);
	}	}
	virtual void handleEndElement(const QStringRef &name, const QStringR ef &uri)	virtual void handleEndElement(const QStringRef &name, const QStringR ef &uri)
	{	{
	if(m_state == AtOption) {	if(m_state == AtOption) {
	m_optionParser.handleEndElement(name,uri);	m_optionParser.handleEndElement(name,uri);
	if(m_depth == 2) {	if(m_depth == 2) {
	Logger::debug() << m_optionParser.create();	Logger::debug() << m_optionParser.create();
	m_options.append(m_optionParser.create());	m_options.append(m_optionParser.create());
	}	}

		} else if(m_state == AtMedia) {
		m_mediaParser.handleEndElement(name, uri);
		if(m_depth == 2)
		m_media = m_mediaParser.create();
	}	}
	if (m_depth <= 2)	if (m_depth <= 2)
	m_state = AtNowhere;	m_state = AtNowhere;
	m_depth--;	m_depth--;
	}	}
	virtual void handleCharacterData(const QStringRef &text)	virtual void handleCharacterData(const QStringRef &text)
	{	{
	switch(m_state) {	switch(m_state) {
	case AtValue:	case AtValue:
	m_values.append(text.toString());	m_values.append(text.toString());
	break;	break;
	case AtOption:	case AtOption:
	m_optionParser.handleCharacterData(text);	m_optionParser.handleCharacterData(text);

		break;
		case AtMedia:
		m_mediaParser.handleCharacterData(text);
		break;
	default:	default:
	break;	break;
	}	}
	}	}
	virtual void serialize(DataFormField field, QXmlStreamWriter write r)	virtual void serialize(DataFormField field, QXmlStreamWriter write r)
	{	{
	writer->writeStartElement(QLatin1String("field"));	writer->writeStartElement(QLatin1String("field"));
	writeAttribute(writer,QLatin1String("type"),enumToStr(field- >type(),datafield_types));	writeAttribute(writer,QLatin1String("type"),enumToStr(field- >type(),datafield_types));
	writeAttribute(writer,QLatin1String("label"),field->descript ion());	writeAttribute(writer,QLatin1String("label"),field->descript ion());
	writeAttribute(writer,QLatin1String("var"),field->var());	writeAttribute(writer,QLatin1String("var"),field->var());

	skipping to change at line 222	skipping to change at line 317
	}	}
	DataFormField create()	DataFormField create()
	{	{
	DataFormField field;	DataFormField field;
	DataFormFieldPrivate *d = DataFormFieldPrivate::get(&field);	DataFormFieldPrivate *d = DataFormFieldPrivate::get(&field);
	d->var = m_var;	d->var = m_var;
	d->values = m_values;	d->values = m_values;
	d->label = m_label;	d->label = m_label;
	d->type = m_type;	d->type = m_type;
	d->options = m_options;	d->options = m_options;

	// Logger::debug() << m_label << m_var << field.var() << field. label() << d->var << d->label;
	d->required = m_required;	d->required = m_required;

		d->media = m_media;
	clear();	clear();
	return field;	return field;
	}	}
	private:	private:
	enum State {	enum State {
	AtValue,	AtValue,
	AtOption,	AtOption,
	AtRequied,	AtRequied,

		AtMedia,
	AtNowhere	AtNowhere
	};	};
	void clear() {	void clear() {
	m_options.clear();	m_options.clear();
	m_type = DataFormField::Invalid;	m_type = DataFormField::Invalid;
	m_label.clear();	m_label.clear();
	m_var.clear();	m_var.clear();
	m_values.clear();	m_values.clear();

		m_media.clear();
	m_required = false;	m_required = false;
	m_state = AtNowhere;	m_state = AtNowhere;
	}	}
	State m_state;	State m_state;

		// QScopedPointer<DataFormFieldPrivate> m_form;
	int m_depth;	int m_depth;
	DataFormField::Type m_type;	DataFormField::Type m_type;
	QString m_label;	QString m_label;
	QString m_var;	QString m_var;
	QStringList m_values;	QStringList m_values;
	QList<QPair<QString, QString> > m_options;	QList<QPair<QString, QString> > m_options;
	bool m_required;	bool m_required;

		DataFormMedia::Ptr m_media;
	DataFormOptionParser m_optionParser;	DataFormOptionParser m_optionParser;

	MultimediaDataFactory m_multimediaDataFactory;	DataFormMediaParser m_mediaParser;
	};	};

	enum DataFormState { AtNowhere, AtTitle, AtInstruction, AtField };	enum DataFormState { AtNowhere, AtTitle, AtInstruction, AtField };

	//static const char* dataform_states[] = {	//static const char* dataform_states[] = {
	// "title",	// "title",
	// "instruction",	// "instruction",
	// "field"	// "field"
	//};	//};

	static const char* dataform_types[] = {	static const char* dataform_types[] = {
	"form",	"form",
	"submit",	"submit",
	"cancel",	"cancel",
	"result"	"result"
	};	};


	class DataFormFactoryPrivate	class JREEN_AUTOTEST_EXPORT DataFormFactoryPrivate
	{	{
	public:	public:
	void clear()	void clear()
	{	{
	title.clear();	title.clear();
	instruction.clear();	instruction.clear();
	fields.clear();	fields.clear();
	formType = DataForm::Invalid;	formType = DataForm::Invalid;
	}	}
	int depth;	int depth;

	skipping to change at line 323	skipping to change at line 422
	{	{
	Q_D(DataFormFactory);	Q_D(DataFormFactory);
	d->depth++;	d->depth++;
	if(d->depth == 1) {	if(d->depth == 1) {
	d->formType = strToEnum<DataForm::Type>(attributes.value(QLa tin1String("type")), dataform_types);	d->formType = strToEnum<DataForm::Type>(attributes.value(QLa tin1String("type")), dataform_types);
	} else if(d->depth == 2) {	} else if(d->depth == 2) {
	if(d->fieldParser.canParse(name, uri, attributes))	if(d->fieldParser.canParse(name, uri, attributes))
	d->state = AtField;	d->state = AtField;
	else if(name == QLatin1String("title"))	else if(name == QLatin1String("title"))
	d->state = AtTitle;	d->state = AtTitle;

	else if(name == QLatin1String("instruction"))	else if(name == QLatin1String("instructions"))
	d->state = AtInstruction;	d->state = AtInstruction;
	else	else
	d->state = AtNowhere;	d->state = AtNowhere;
	}	}
	if(d->state == AtField)	if(d->state == AtField)
	d->fieldParser.handleStartElement(name,uri,attributes);	d->fieldParser.handleStartElement(name,uri,attributes);
	}	}

	void DataFormFactory::handleEndElement(const QStringRef &name, const QStrin gRef &uri)	void DataFormFactory::handleEndElement(const QStringRef &name, const QStrin gRef &uri)
	{	{

	skipping to change at line 353	skipping to change at line 452
	}	}
	d->depth--;	d->depth--;
	}	}

	void DataFormFactory::handleCharacterData(const QStringRef &text)	void DataFormFactory::handleCharacterData(const QStringRef &text)
	{	{
	Q_D(DataFormFactory);	Q_D(DataFormFactory);
	switch(d->state) {	switch(d->state) {
	case AtTitle:	case AtTitle:
	d->title = text.toString();	d->title = text.toString();

		break;
	case AtInstruction:	case AtInstruction:
	d->instruction = text.toString();	d->instruction = text.toString();

		break;
	case AtField:	case AtField:
	d->fieldParser.handleCharacterData(text);	d->fieldParser.handleCharacterData(text);

		break;
	default:	default:
	break;	break;
	}	}
	}	}

	void DataFormFactory::serialize(Payload extension, QXmlStreamWriter write r)	void DataFormFactory::serialize(Payload extension, QXmlStreamWriter write r)
	{	{
	Q_D(DataFormFactory);	Q_D(DataFormFactory);
	DataForm form = se_cast<DataForm>(extension);	DataForm form = se_cast<DataForm>(extension);
	writer->writeStartElement(QLatin1String("x"));	writer->writeStartElement(QLatin1String("x"));

	skipping to change at line 379	skipping to change at line 481
	writer->writeAttribute(QLatin1String("type"), enumToStr(form ->type(), dataform_types));	writer->writeAttribute(QLatin1String("type"), enumToStr(form ->type(), dataform_types));
	writeTextElement(writer,QLatin1String("title"), form->title());	writeTextElement(writer,QLatin1String("title"), form->title());
	// writer->writeTextElement(QLatin1String("instruction"), form->));	// writer->writeTextElement(QLatin1String("instruction"), form->));
	d->fieldParser.serialize(*form, writer);	d->fieldParser.serialize(*form, writer);
	writer->writeEndElement();	writer->writeEndElement();
	}	}

	Payload::Ptr DataFormFactory::createPayload()	Payload::Ptr DataFormFactory::createPayload()
	{	{
	Q_D(DataFormFactory);	Q_D(DataFormFactory);

	DataForm *form = new DataForm(d->formType,d->title);	DataForm *form = new DataForm(d->formType, d->title, d->instruction) ;
	form->setFields(d->fields);	form->setFields(d->fields);
	d->clear();	d->clear();
	return Payload::Ptr(form);	return Payload::Ptr(form);
	}	}

	} // namespace Jreen	} // namespace Jreen

End of changes. 22 change blocks.
	7 lines changed or deleted	120 lines changed or added
This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/