More JVoiceXML integration

4 files changed, 323 insertions, 311 deletions

diff --git a/src/uscxml/messages/Event.cpp b/src/uscxml/messages/Event.cpp
index 43c6600..fda24dd 100644
--- a/src/uscxml/messages/Event.cpp
+++ b/src/uscxml/messages/Event.cpp
@@ -72,29 +72,6 @@ Arabica::DOM::Document<std::string> Event::toDocument() {
 	return document;
 }
 
-void Event::initContent(const std::string& content) {
-	// try to parse as JSON
-	Data json = Data::fromJSON(content);
-	if (!json.empty()) {
-		data = json;
-		return;
-	}
-
-	// try to parse as XML
-	Arabica::SAX2DOM::Parser<std::string> parser;
-	Arabica::SAX::CatchErrorHandler<std::string> errorHandler;
-	parser.setErrorHandler(errorHandler);
-
-	std::istringstream is(content);
-	Arabica::SAX::InputSource<std::string> inputSource;
-	inputSource.setByteStream(is);
-	if (parser.parse(inputSource)) {
-		dom = parser.getDocument();
-		return;
-	}
-
-	this->content = content;
-}
 
 Event Event::fromXML(const std::string& xmlString) {
 	Arabica::SAX2DOM::Parser<std::string> eventParser;
diff --git a/src/uscxml/messages/Event.h b/src/uscxml/messages/Event.h
index a63c55f..d282fc2 100644
--- a/src/uscxml/messages/Event.h
+++ b/src/uscxml/messages/Event.h
@@ -182,8 +182,6 @@ public:
 		this->data = data;
 	}
 
-	void initContent(const std::string& content);
-
 	static Event fromXML(const std::string& xmlString);
 	Arabica::DOM::Document<std::string> toDocument();
 	std::string toXMLString();
diff --git a/src/uscxml/messages/MMIMessages.cpp b/src/uscxml/messages/MMIMessages.cpp
index 01705ed..dffda5b 100644
--- a/src/uscxml/messages/MMIMessages.cpp
+++ b/src/uscxml/messages/MMIMessages.cpp
@@ -28,6 +28,30 @@
 
 #include <boost/algorithm/string.hpp>
 
+#define TO_EVENT_OPERATOR(type, name, base)\
+type::operator Event() const { \
+	Event ev = base::operator Event();\
+	ev.setName(name);\
+	if (representation == MMI_AS_XML) \
+		ev.setDOM(toXML());\
+	return ev;\
+}
+
+#define FIND_MSG_ELEM(elem, doc) \
+Element<std::string> elem; \
+if (encapsulateInMMI) { \
+	elem = Element<std::string>(doc.getDocumentElement().getFirstChild()); \
+} else { \
+	elem = Element<std::string>(doc.getDocumentElement()); \
+}
+
+#define FROM_XML(clazz, enumType, base) \
+clazz clazz::fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter) { \
+	clazz event = base::fromXML(node, interpreter); \
+	event.type = enumType; \
+	return event; \
+}
+
 #define STRING_ATTR_OR_EXPR(element, name)\
 (element.hasAttributeNS(nameSpace, "name##Expr") && interpreter ? \
 	interpreter->getDataModel().evalAsString(element.getAttributeNS(nameSpace, "name##Expr")) : \
@@ -35,6 +59,8 @@
 )
 
 #define FIND_EVENT_NODE(node)\
+if (node.getNodeType() == Node_base::DOCUMENT_NODE) \
+	node = node.getFirstChild(); \
 while (node) {\
 	if (node.getNodeType() == Node_base::ELEMENT_NODE) {\
 		if (boost::iequals(node.getLocalName(), "MMI")) {\
@@ -117,16 +143,16 @@ Arabica::DOM::Document<std::string> MMIEvent::toXML(bool encapsulateInMMI) const
 	msgElem.setAttributeNS(nameSpace, "Target", target);
 	msgElem.setAttributeNS(nameSpace, "RequestID", requestId);
 
-	if (data.size() > 0) {
-		Element<std::string> dataElem = doc.createElementNS(nameSpace, "Data");
-		Text<std::string> textElem = doc.createTextNode(data);
-		dataElem.appendChild(textElem);
-		msgElem.appendChild(dataElem);
-	} else if (dataDOM) {
+	if (dataDOM) {
 		Element<std::string> dataElem = doc.createElementNS(nameSpace, "Data");
 		Node<std::string> importNode = doc.importNode(dataDOM, true);
 		dataElem.appendChild(importNode);
 		msgElem.appendChild(dataElem);
+	}	else if (data.size() > 0) {
+		Element<std::string> dataElem = doc.createElementNS(nameSpace, "Data");
+		Text<std::string> textElem = doc.createTextNode(data);
+		dataElem.appendChild(textElem);
+		msgElem.appendChild(dataElem);
 	}
 
 	if (encapsulateInMMI) {
@@ -139,16 +165,9 @@ Arabica::DOM::Document<std::string> MMIEvent::toXML(bool encapsulateInMMI) const
 	return doc;
 }
 
-Arabica::DOM::Document<std::string> ContextualizedRequest::toXML(bool encapsulateInMMI) const {
-	Document<std::string> doc = MMIEvent::toXML(encapsulateInMMI);
-	Element<std::string> msgElem = Element<std::string>(doc.getDocumentElement().getFirstChild());
-	msgElem.setAttributeNS(nameSpace, "Context", context);
-	return doc;
-}
-
 Arabica::DOM::Document<std::string> ContentRequest::toXML(bool encapsulateInMMI) const {
 	Document<std::string> doc = ContextualizedRequest::toXML(encapsulateInMMI);
-	Element<std::string> msgElem = Element<std::string>(doc.getDocumentElement().getFirstChild());
+	FIND_MSG_ELEM(msgElem, doc);
 
 	if (contentURL.href.size() > 0) {
 		Element<std::string> contentURLElem = doc.createElementNS(nameSpace, "ContentURL");
@@ -170,16 +189,23 @@ Arabica::DOM::Document<std::string> ContentRequest::toXML(bool encapsulateInMMI)
 	return doc;
 }
 
+Arabica::DOM::Document<std::string> ContextualizedRequest::toXML(bool encapsulateInMMI) const {
+	Document<std::string> doc = MMIEvent::toXML(encapsulateInMMI);
+	FIND_MSG_ELEM(msgElem, doc);
+	msgElem.setAttributeNS(nameSpace, "Context", context);
+	return doc;
+}
+
 Arabica::DOM::Document<std::string> ExtensionNotification::toXML(bool encapsulateInMMI) const {
 	Document<std::string> doc = ContextualizedRequest::toXML(encapsulateInMMI);
-	Element<std::string> msgElem = Element<std::string>(doc.getDocumentElement().getFirstChild());
+	FIND_MSG_ELEM(msgElem, doc);
 	msgElem.setAttributeNS(nameSpace, "Name", name);
 	return doc;
 }
 
 Arabica::DOM::Document<std::string> StatusResponse::toXML(bool encapsulateInMMI) const {
 	Document<std::string> doc = ContextualizedRequest::toXML(encapsulateInMMI);
-	Element<std::string> msgElem = Element<std::string>(doc.getDocumentElement().getFirstChild());
+	FIND_MSG_ELEM(msgElem, doc);
 	if (status == ALIVE) {
 		msgElem.setAttributeNS(nameSpace, "Status", "alive");
 	} else if(status == DEAD) {
@@ -194,7 +220,7 @@ Arabica::DOM::Document<std::string> StatusResponse::toXML(bool encapsulateInMMI)
 
 Arabica::DOM::Document<std::string> StatusInfoResponse::toXML(bool encapsulateInMMI) const {
 	Document<std::string> doc = StatusResponse::toXML(encapsulateInMMI);
-	Element<std::string> msgElem = Element<std::string>(doc.getDocumentElement().getFirstChild());
+	FIND_MSG_ELEM(msgElem, doc);
 
 	Element<std::string> statusInfoElem = doc.createElementNS(nameSpace, "StatusInfo");
 	Text<std::string> statusInfoText = doc.createTextNode(statusInfo);
@@ -206,7 +232,7 @@ Arabica::DOM::Document<std::string> StatusInfoResponse::toXML(bool encapsulateIn
 
 Arabica::DOM::Document<std::string> StatusRequest::toXML(bool encapsulateInMMI) const {
 	Document<std::string> doc = ContextualizedRequest::toXML(encapsulateInMMI);
-	Element<std::string> msgElem = Element<std::string>(doc.getDocumentElement().getFirstChild());
+	FIND_MSG_ELEM(msgElem, doc);
 
 	if (automaticUpdate) {
 		msgElem.setAttributeNS(nameSpace, "RequestAutomaticUpdate", "true");
@@ -217,18 +243,22 @@ Arabica::DOM::Document<std::string> StatusRequest::toXML(bool encapsulateInMMI)
 	return doc;
 }
 
+	
+
 MMIEvent MMIEvent::fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter) {
 	MMIEvent msg;
+
 	FIND_EVENT_NODE(node);
 
 	Element<std::string> msgElem(node);
 	msg.source = STRING_ATTR_OR_EXPR(msgElem, Source);
 	msg.target = STRING_ATTR_OR_EXPR(msgElem, Target);
-//	msg.data = STRING_ATTR_OR_EXPR(msgElem, Data);
 	msg.requestId = STRING_ATTR_OR_EXPR(msgElem, RequestID);
 	msg.tagName = msgElem.getLocalName();
 
 	Element<std::string> dataElem;
+	
+	// search for data element
 	node = msgElem.getFirstChild();
 	while (node) {
 		if (node.getNodeType() == Node_base::ELEMENT_NODE)
@@ -239,47 +269,60 @@ MMIEvent MMIEvent::fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl
 	}
 
 	if (dataElem && boost::iequals(dataElem.getLocalName(), "data") && dataElem.getFirstChild()) {
-		node = dataElem.getFirstChild();
-		if (node.getNodeType() == Arabica::DOM::Node_base::ELEMENT_NODE) {
-			msg.dataDOM = node;
-		} else {
-			std::stringstream ss;
-			ss << node;
-			msg.data = ss.str();
+		Arabica::DOM::Node<std::string> dataChild = dataElem.getFirstChild();
+		std::stringstream ss;
+
+		while (dataChild) {
+			if (dataChild.getNodeType() == Arabica::DOM::Node_base::ELEMENT_NODE)
+				msg.dataDOM = dataChild;
+			ss << dataChild;
+			dataChild = dataChild.getNextSibling();
 		}
+		msg.data = ss.str();
 	}
 
 	return msg;
 }
 
-MMIEvent::operator Event() const {
-	Event ev;
-	ev.setOriginType("mmi.event");
-	ev.setOrigin(source);
-	ev.setRaw(data);
-	ev.setSendId(requestId);
-	if (data.length() > 0) {
-		ev.initContent(data);
-	}
-	return ev;
-}
+FROM_XML(NewContextRequest,    NEWCONTEXTREQUEST,    MMIEvent)
+
+FROM_XML(PauseRequest,         PAUSEREQUEST,         ContextualizedRequest)
+FROM_XML(ResumeRequest,        RESUMEREQUEST,        ContextualizedRequest)
+FROM_XML(ClearContextRequest,  CLEARCONTEXTREQUEST,  ContextualizedRequest)
+FROM_XML(CancelRequest,        CANCELREQUEST,        ContextualizedRequest)
+
+FROM_XML(PrepareRequest,       PREPAREREQUEST,       ContentRequest)
+FROM_XML(StartRequest,         STARTREQUEST,         ContentRequest)
+
+FROM_XML(PrepareResponse,      PREPARERESPONSE,      StatusInfoResponse)
+FROM_XML(StartResponse,        STARTRESPONSE,        StatusInfoResponse)
+FROM_XML(CancelResponse,       CANCELRESPONSE,       StatusInfoResponse)
+FROM_XML(PauseResponse,        PAUSERESPONSE,        StatusInfoResponse)
+FROM_XML(ResumeResponse,       RESUMERESPONSE,       StatusInfoResponse)
+FROM_XML(ClearContextResponse, CLEARCONTEXTRESPONSE, StatusInfoResponse)
+FROM_XML(NewContextResponse,   NEWCONTEXTRESPONSE,   StatusInfoResponse)
+FROM_XML(DoneNotification,     DONENOTIFICATION,     StatusInfoResponse)
+
 
 ContextualizedRequest ContextualizedRequest::fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter) {
 	ContextualizedRequest msg(MMIEvent::fromXML(node, interpreter));
 	FIND_EVENT_NODE(node);
-
+	
 	Element<std::string> msgElem(node);
 	msg.context = STRING_ATTR_OR_EXPR(msgElem, Context);
 	return msg;
 }
 
-ContextualizedRequest::operator Event() const {
-	Event ev = MMIEvent::operator Event();
-	// do we want to represent the context? It's the interpreters name already
-	return ev;
+ExtensionNotification ExtensionNotification::fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter) {
+	ExtensionNotification msg(ContextualizedRequest::fromXML(node, interpreter));
+	FIND_EVENT_NODE(node);
+	
+	Element<std::string> msgElem(node);
+	msg.name = STRING_ATTR_OR_EXPR(msgElem, Name);
+	msg.type = EXTENSIONNOTIFICATION;
+	return msg;
 }
 
-
 ContentRequest ContentRequest::fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter) {
 	ContentRequest msg(ContextualizedRequest::fromXML(node, interpreter));
 	FIND_EVENT_NODE(node);
@@ -300,16 +343,17 @@ ContentRequest ContentRequest::fromXML(Arabica::DOM::Node<std::string> node, Int
 
 	if (contentElem) {
 		if(boost::iequals(contentElem.getLocalName(), "content")) {
+			Arabica::DOM::Node<std::string> contentChild = contentElem.getFirstChild();
 			std::stringstream ss;
-			node = contentElem.getFirstChild();
-			while (node) {
-				if (node.getNodeType() == Node_base::ELEMENT_NODE) {
-					ss << node;
-					break;
-				}
-				node = node.getNextSibling();
+			
+			while (contentChild) {
+				if (contentChild.getNodeType() == Arabica::DOM::Node_base::ELEMENT_NODE)
+					msg.contentDOM = contentChild;
+				ss << contentChild;
+				contentChild = contentChild.getNextSibling();
 			}
 			msg.content = ss.str();
+			
 		} else if(boost::iequals(contentElem.getLocalName(), "contentURL")) {
 			msg.contentURL.href = STRING_ATTR_OR_EXPR(contentElem, href);
 			msg.contentURL.maxAge = STRING_ATTR_OR_EXPR(contentElem, max-age);
@@ -321,26 +365,6 @@ ContentRequest ContentRequest::fromXML(Arabica::DOM::Node<std::string> node, Int
 	return msg;
 }
 
-ExtensionNotification ExtensionNotification::fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter) {
-	ExtensionNotification msg(ContextualizedRequest::fromXML(node, interpreter));
-	FIND_EVENT_NODE(node);
-
-	Element<std::string> msgElem(node);
-	msg.name = STRING_ATTR_OR_EXPR(msgElem, Name);
-	msg.type = EXTENSIONNOTIFICATION;
-	return msg;
-}
-
-ExtensionNotification::operator Event() const {
-	Event ev = ContextualizedRequest::operator Event();
-	if (name.length() > 0) {
-		ev.setName("mmi.extensionnotification." + name);
-	} else {
-		ev.setName("mmi.extensionnotification");
-	}
-	return ev;
-}
-
 StatusResponse StatusResponse::fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter) {
 	StatusResponse msg(ContextualizedRequest::fromXML(node, interpreter));
 	FIND_EVENT_NODE(node);
@@ -416,5 +440,108 @@ StatusRequest StatusRequest::fromXML(Arabica::DOM::Node<std::string> node, Inter
 	return msg;
 }
 
+	
+
+#ifdef MMI_WITH_OPERATOR_EVENT
+	
+	TO_EVENT_OPERATOR(NewContextRequest,    "mmi.request.newcontext",    MMIEvent);
+	TO_EVENT_OPERATOR(PauseRequest,         "mmi.request.pause",         ContextualizedRequest);
+	TO_EVENT_OPERATOR(ResumeRequest,        "mmi.request.resume",        ContextualizedRequest);
+	TO_EVENT_OPERATOR(CancelRequest,        "mmi.request.cancel",        ContextualizedRequest);
+	TO_EVENT_OPERATOR(ClearContextRequest,  "mmi.request.clearcontext",  ContextualizedRequest);
+	TO_EVENT_OPERATOR(StatusRequest,        "mmi.request.status",        ContextualizedRequest);
+	
+	TO_EVENT_OPERATOR(PrepareRequest,       "mmi.request.prepare",       ContentRequest);
+	TO_EVENT_OPERATOR(StartRequest,         "mmi.request.start",         ContentRequest);
+	
+	TO_EVENT_OPERATOR(PrepareResponse,      "mmi.response.prepare",      StatusInfoResponse);
+	TO_EVENT_OPERATOR(StartResponse,        "mmi.response.start",        StatusInfoResponse);
+	TO_EVENT_OPERATOR(CancelResponse,       "mmi.response.cancel",       StatusInfoResponse);
+	TO_EVENT_OPERATOR(PauseResponse,        "mmi.response.pause",        StatusInfoResponse);
+	TO_EVENT_OPERATOR(ResumeResponse,       "mmi.response.resume",       StatusInfoResponse);
+	TO_EVENT_OPERATOR(ClearContextResponse, "mmi.response.clearcontext", StatusInfoResponse);
+	TO_EVENT_OPERATOR(NewContextResponse,   "mmi.response.newcontext",   StatusInfoResponse);
+	TO_EVENT_OPERATOR(DoneNotification,     "mmi.notification.done",     StatusInfoResponse);
+
+	
+	MMIEvent::operator Event() const {
+		Event ev;
+		ev.setOriginType("mmi.event");
+		ev.setOrigin(source);
+		
+		if (representation == MMI_AS_DATA) {
+			if (dataDOM) {
+				ev.data.node = dataDOM;
+			} else {
+				ev.data = Data::fromJSON(data);
+				if (ev.data.empty()) {
+					ev.content = data;
+				}
+			}
+		}
+		return ev;
+	}
+	
+	ContextualizedRequest::operator Event() const {
+		Event ev = MMIEvent::operator Event();
+		// do we want to represent the context? It's the interpreters name already
+		return ev;
+	}
+
+	ExtensionNotification::operator Event() const {
+		Event ev = ContextualizedRequest::operator Event();
+		if (name.length() > 0) {
+			ev.setName(name);
+		} else {
+			ev.setName("mmi.notification.extension");
+		}
+		return ev;
+	}
+
+	ContentRequest::operator Event() const {
+		Event ev = ContextualizedRequest::operator Event();
+		if (representation == MMI_AS_DATA) {
+			if (content.length() > 0)
+				ev.data.compound["content"] = Data(content, Data::VERBATIM);
+			if (contentURL.fetchTimeout.length() > 0)
+				ev.data.compound["contentURL"].compound["fetchTimeout"] = Data(contentURL.fetchTimeout, Data::VERBATIM);
+			if (contentURL.href.length() > 0)
+				ev.data.compound["contentURL"].compound["href"] = Data(contentURL.href, Data::VERBATIM);
+			if (contentURL.maxAge.length() > 0)
+				ev.data.compound["contentURL"].compound["maxAge"] = Data(contentURL.maxAge, Data::VERBATIM);
+		}
+		return ev;
+	}
+
+	StatusResponse::operator Event() const {
+		Event ev = ContextualizedRequest::operator Event();
+		ev.setName("mmi.response.status");
+
+		if (representation == MMI_AS_DATA) {
+			switch (status) {
+				case ALIVE:
+					ev.data.compound["status"] = Data("alive", Data::VERBATIM);
+					break;
+				case DEAD:
+					ev.data.compound["status"] = Data("dead", Data::VERBATIM);
+					break;
+				case SUCCESS:
+					ev.data.compound["status"] = Data("success", Data::VERBATIM);
+					break;
+				case FAILURE:
+					ev.data.compound["status"] = Data("failure", Data::VERBATIM);
+					break;
+				default:
+					ev.data.compound["status"] = Data("invalid", Data::VERBATIM);
+			}
+		} else {
+			ev.dom = toXML();
+		}
+		
+		return ev;
+	}
+
+#endif
+
 
 }
\ No newline at end of file
diff --git a/src/uscxml/messages/MMIMessages.h b/src/uscxml/messages/MMIMessages.h
index c6a2fce..2cffa0f 100644
--- a/src/uscxml/messages/MMIMessages.h
+++ b/src/uscxml/messages/MMIMessages.h
@@ -20,6 +20,8 @@
 #ifndef MMIEVENT_H_OS0SE7H5
 #define MMIEVENT_H_OS0SE7H5
 
+#define MMI_WITH_OPERATOR_EVENT 1
+
 #include <DOM/Node.hpp>
 #include <DOM/Document.hpp>
 #include <uscxml/Interpreter.h>
@@ -50,37 +52,34 @@ public:
 		INVALID
 	};
 
+	enum RepresentationType {
+		MMI_AS_DATA,
+		MMI_AS_XML
+	};
 	static Type getType(Arabica::DOM::Node<std::string> node);
 
-	virtual Arabica::DOM::Document<std::string> toXML(bool encapsulateInMMI = false) const;
-	static MMIEvent fromXML(Arabica::DOM::Node<std::string> node,
-	                        InterpreterImpl* interpreter = NULL);
+	virtual Arabica::DOM::Document<std::string> toXML(bool encapsulateInMMI = true) const;
+	static MMIEvent fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
 
+#ifdef MMI_WITH_OPERATOR_EVENT
 	// conversion operator
 	operator Event() const;
-
+#endif
+	
 	std::string source;
 	std::string target;
 	std::string data;
 	Arabica::DOM::Node<std::string> dataDOM;
 	std::string requestId;
+	
 	std::string tagName;
 	Type type;
-
+	RepresentationType representation;
+	
 	static std::string nameSpace;
 
 protected:
-	MMIEvent() {}
-};
-
-class MMIEventReceiver {
-public:
-	virtual void received(const MMIEvent& mmiEvent) = 0;
-};
-
-class MMIEventSender {
-public:
-	virtual void send(const MMIEvent& mmiEvent) = 0;
+	MMIEvent() : representation(MMI_AS_DATA) {}
 };
 
 class NewContextRequest : public MMIEvent {
@@ -90,27 +89,24 @@ public:
 		type = NEWCONTEXTREQUEST;
 	}
 	NewContextRequest(const MMIEvent& father) : MMIEvent(father) {}
-	static NewContextRequest fromXML(Arabica::DOM::Node<std::string> node,
-	                                 InterpreterImpl* interpreter = NULL) {
-		MMIEvent event = MMIEvent::fromXML(node, interpreter);
-		event.type = NEWCONTEXTREQUEST;
-		return event;
-	}
-	operator Event() const {
-		Event ev = MMIEvent::operator Event();
-		ev.setName("mmi.newcontextrequest");
-		ev.setDOM(toXML());
-		return ev;
-	}
+	static NewContextRequest fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
+
+#ifdef MMI_WITH_OPERATOR_EVENT
+	operator Event() const;
+#endif
+	
 	std::string token; ///< special token for server-less modality components
 };
 
 class ContextualizedRequest : public MMIEvent {
 public:
-	virtual Arabica::DOM::Document<std::string> toXML(bool encapsulateInMMI = false) const;
-	static ContextualizedRequest fromXML(Arabica::DOM::Node<std::string> node,
-	                                     InterpreterImpl* interpreter = NULL);
+	virtual Arabica::DOM::Document<std::string> toXML(bool encapsulateInMMI = true) const;
+	static ContextualizedRequest fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
+	
+#ifdef MMI_WITH_OPERATOR_EVENT
 	operator Event() const;
+#endif
+	
 	std::string context;
 protected:
 	ContextualizedRequest() {}
@@ -124,19 +120,12 @@ public:
 		type = PAUSEREQUEST;
 	}
 	PauseRequest(const ContextualizedRequest& father) : ContextualizedRequest(father) {}
-	static PauseRequest fromXML(Arabica::DOM::Node<std::string> node,
-	                            InterpreterImpl* interpreter = NULL) {
-		PauseRequest event = ContextualizedRequest::fromXML(node, interpreter);
-		event.type = PAUSEREQUEST;
-		return event;
-	}
-	operator Event() const {
-		Event ev = ContextualizedRequest::operator Event();
-		ev.setName("mmi.pauserequest");
-		ev.setDOM(toXML());
-		return ev;
-	}
-
+	static PauseRequest fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
+	
+#ifdef MMI_WITH_OPERATOR_EVENT
+	operator Event() const;
+#endif
+	
 };
 class ResumeRequest : public ContextualizedRequest {
 public:
@@ -145,19 +134,12 @@ public:
 		type = RESUMEREQUEST;
 	}
 	ResumeRequest(const ContextualizedRequest& father) : ContextualizedRequest(father) {}
-	static ResumeRequest fromXML(Arabica::DOM::Node<std::string> node,
-	                             InterpreterImpl* interpreter = NULL) {
-		ResumeRequest event = ContextualizedRequest::fromXML(node, interpreter);
-		event.type = RESUMEREQUEST;
-		return event;
-	}
-	operator Event() const {
-		Event ev = ContextualizedRequest::operator Event();
-		ev.setDOM(toXML());
-		ev.setName("mmi.resumerequest");
-		return ev;
-	}
-
+	static ResumeRequest fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
+	
+#ifdef MMI_WITH_OPERATOR_EVENT
+	operator Event() const;
+#endif
+	
 };
 class CancelRequest : public ContextualizedRequest {
 public:
@@ -166,18 +148,11 @@ public:
 		type = CANCELREQUEST;
 	}
 	CancelRequest(const ContextualizedRequest& father) : ContextualizedRequest(father) {}
-	static CancelRequest fromXML(Arabica::DOM::Node<std::string> node,
-	                             InterpreterImpl* interpreter = NULL) {
-		CancelRequest event = ContextualizedRequest::fromXML(node, interpreter);
-		event.type = CANCELREQUEST;
-		return event;
-	}
-	operator Event() const {
-		Event ev = ContextualizedRequest::operator Event();
-		ev.setName("mmi.cancelrequest");
-		ev.setDOM(toXML());
-		return ev;
-	}
+	static CancelRequest fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
+	
+#ifdef MMI_WITH_OPERATOR_EVENT
+	operator Event() const;
+#endif
 
 };
 class ClearContextRequest : public ContextualizedRequest {
@@ -187,19 +162,12 @@ public:
 		type = CLEARCONTEXTREQUEST;
 	}
 	ClearContextRequest(const ContextualizedRequest& father) : ContextualizedRequest(father) {}
-	static ClearContextRequest fromXML(Arabica::DOM::Node<std::string> node,
-	                                   InterpreterImpl* interpreter = NULL) {
-		ClearContextRequest event = ContextualizedRequest::fromXML(node, interpreter);
-		event.type = CLEARCONTEXTREQUEST;
-		return event;
-	}
-	operator Event() const {
-		Event ev = ContextualizedRequest::operator Event();
-		ev.setName("mmi.clearcontextrequest");
-		ev.setDOM(toXML());
-		return ev;
-	}
+	static ClearContextRequest fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
 
+#ifdef MMI_WITH_OPERATOR_EVENT
+	operator Event() const;
+#endif
+	
 };
 class StatusRequest : public ContextualizedRequest {
 public:
@@ -207,10 +175,13 @@ public:
 		tagName = "StatusRequest";
 		type = STARTREQUEST;
 	}
-	virtual Arabica::DOM::Document<std::string> toXML(bool encapsulateInMMI = false) const;
-	static StatusRequest fromXML(Arabica::DOM::Node<std::string> node,
-	                             InterpreterImpl* interpreter = NULL);
+	virtual Arabica::DOM::Document<std::string> toXML(bool encapsulateInMMI = true) const;
+	static StatusRequest fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
+
+#ifdef MMI_WITH_OPERATOR_EVENT
 	operator Event() const;
+#endif
+	
 	bool automaticUpdate;
 protected:
 	StatusRequest(const ContextualizedRequest& father) : ContextualizedRequest(father) {}
@@ -224,10 +195,13 @@ public:
 		std::string fetchTimeout;
 	};
 
-	virtual Arabica::DOM::Document<std::string> toXML(bool encapsulateInMMI = false) const;
-	static ContentRequest fromXML(Arabica::DOM::Node<std::string> node,
-	                              InterpreterImpl* interpreter = NULL);
+	virtual Arabica::DOM::Document<std::string> toXML(bool encapsulateInMMI = true) const;
+	static ContentRequest fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
+
+#ifdef MMI_WITH_OPERATOR_EVENT
 	operator Event() const;
+#endif
+	
 	std::string content;
 	Arabica::DOM::Node<std::string> contentDOM;
 	ContentURL contentURL;
@@ -243,18 +217,11 @@ public:
 		type = PREPAREREQUEST;
 	}
 	PrepareRequest(const ContentRequest& father) : ContentRequest(father) {}
-	static PrepareRequest fromXML(Arabica::DOM::Node<std::string> node,
-	                              InterpreterImpl* interpreter = NULL) {
-		PrepareRequest event = ContentRequest::fromXML(node, interpreter);
-		event.type = PREPAREREQUEST;
-		return event;
-	}
-	operator Event() const {
-		Event ev = ContentRequest::operator Event();
-		ev.setName("mmi.preparerequest");
-		ev.setDOM(toXML());
-		return ev;
-	}
+	static PrepareRequest fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
+
+#ifdef MMI_WITH_OPERATOR_EVENT
+	operator Event() const;
+#endif
 };
 
 class StartRequest : public ContentRequest {
@@ -264,18 +231,11 @@ public:
 		type = STARTREQUEST;
 	}
 	StartRequest(const ContentRequest& father) : ContentRequest(father) {}
-	static StartRequest fromXML(Arabica::DOM::Node<std::string> node,
-	                            InterpreterImpl* interpreter = NULL) {
-		StartRequest event = ContentRequest::fromXML(node, interpreter);
-		event.type = STARTREQUEST;
-		return event;
-	}
-	operator Event() const {
-		Event ev = ContentRequest::operator Event();
-		ev.setName("mmi.startrequest");
-		ev.setDOM(toXML());
-		return ev;
-	}
+	static StartRequest fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
+
+#ifdef MMI_WITH_OPERATOR_EVENT
+	operator Event() const;
+#endif
 
 };
 
@@ -285,10 +245,13 @@ public:
 		tagName = "ExtensionNotification";
 		type = EXTENSIONNOTIFICATION;
 	}
-	virtual Arabica::DOM::Document<std::string> toXML(bool encapsulateInMMI = false) const;
-	static ExtensionNotification fromXML(Arabica::DOM::Node<std::string> node,
-	                                     InterpreterImpl* interpreter = NULL);
+	virtual Arabica::DOM::Document<std::string> toXML(bool encapsulateInMMI = true) const;
+	static ExtensionNotification fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
+
+#ifdef MMI_WITH_OPERATOR_EVENT
 	operator Event() const;
+#endif
+	
 	std::string name;
 protected:
 	ExtensionNotification(const ContextualizedRequest& father) : ContextualizedRequest(father) {}
@@ -310,9 +273,13 @@ public:
 		type = STATUSRESPONSE;
 		status = INVALID;
 	}
-	virtual Arabica::DOM::Document<std::string> toXML(bool encapsulateInMMI = false) const;
-	static StatusResponse fromXML(Arabica::DOM::Node<std::string> node,
-	                              InterpreterImpl* interpreter = NULL);
+	virtual Arabica::DOM::Document<std::string> toXML(bool encapsulateInMMI = true) const;
+	static StatusResponse fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
+	
+#ifdef MMI_WITH_OPERATOR_EVENT
+	operator Event() const;
+#endif
+
 	Status status;
 protected:
 	StatusResponse(const ContextualizedRequest& father) : ContextualizedRequest(father) {}
@@ -320,10 +287,9 @@ protected:
 
 class StatusInfoResponse : public StatusResponse {
 public:
-	virtual Arabica::DOM::Document<std::string> toXML(bool encapsulateInMMI = false) const;
+	virtual Arabica::DOM::Document<std::string> toXML(bool encapsulateInMMI = true) const;
 	StatusInfoResponse(const StatusResponse& father) : StatusResponse(father) {}
-	static StatusInfoResponse fromXML(Arabica::DOM::Node<std::string> node,
-	                                  InterpreterImpl* interpreter = NULL);
+	static StatusInfoResponse fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
 	std::string statusInfo;
 protected:
 	StatusInfoResponse() {}
@@ -336,18 +302,12 @@ public:
 		type = PREPARERESPONSE;
 	}
 	PrepareResponse(const StatusInfoResponse& father) : StatusInfoResponse(father) {}
-	static PrepareResponse fromXML(Arabica::DOM::Node<std::string> node,
-	                               InterpreterImpl* interpreter = NULL) {
-		PrepareResponse event = StatusInfoResponse::fromXML(node, interpreter);
-		event.type = PREPARERESPONSE;
-		return event;
-	}
-	operator Event() const {
-		Event ev = StatusInfoResponse::operator Event();
-		ev.setName("mmi.prepareresponse");
-		ev.setDOM(toXML());
-		return ev;
-	}
+	static PrepareResponse fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
+	
+#ifdef MMI_WITH_OPERATOR_EVENT
+	operator Event() const;
+#endif
+	
 };
 
 class StartResponse : public StatusInfoResponse {
@@ -357,18 +317,11 @@ public:
 		type = STARTRESPONSE;
 	}
 	StartResponse(const StatusInfoResponse& father) : StatusInfoResponse(father) {}
-	static StartResponse fromXML(Arabica::DOM::Node<std::string> node,
-	                             InterpreterImpl* interpreter = NULL) {
-		StartResponse event = StatusInfoResponse::fromXML(node, interpreter);
-		event.type = STARTRESPONSE;
-		return event;
-	}
-	operator Event() const {
-		Event ev = StatusInfoResponse::operator Event();
-		ev.setName("mmi.startresponse");
-		ev.setDOM(toXML());
-		return ev;
-	}
+	static StartResponse fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
+	
+#ifdef MMI_WITH_OPERATOR_EVENT
+	operator Event() const;
+#endif
 };
 
 class CancelResponse : public StatusInfoResponse {
@@ -378,18 +331,11 @@ public:
 		type = CANCELRESPONSE;
 	}
 	CancelResponse(const StatusInfoResponse& father) : StatusInfoResponse(father) {}
-	static CancelResponse fromXML(Arabica::DOM::Node<std::string> node,
-	                              InterpreterImpl* interpreter = NULL) {
-		CancelResponse event = StatusInfoResponse::fromXML(node, interpreter);
-		event.type = CANCELRESPONSE;
-		return event;
-	}
-	operator Event() const {
-		Event ev = StatusInfoResponse::operator Event();
-		ev.setName("mmi.cancelresponse");
-		ev.setDOM(toXML());
-		return ev;
-	}
+	static CancelResponse fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
+	
+#ifdef MMI_WITH_OPERATOR_EVENT
+	operator Event() const;
+#endif
 };
 
 class PauseResponse : public StatusInfoResponse {
@@ -399,18 +345,11 @@ public:
 		type = PAUSERESPONSE;
 	}
 	PauseResponse(const StatusInfoResponse& father) : StatusInfoResponse(father) {}
-	static PauseResponse fromXML(Arabica::DOM::Node<std::string> node,
-	                             InterpreterImpl* interpreter = NULL) {
-		PauseResponse event = StatusInfoResponse::fromXML(node, interpreter);
-		event.type = PAUSERESPONSE;
-		return event;
-	}
-	operator Event() const {
-		Event ev = StatusInfoResponse::operator Event();
-		ev.setName("mmi.pauseresponse");
-		ev.setDOM(toXML());
-		return ev;
-	}
+	static PauseResponse fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
+	
+#ifdef MMI_WITH_OPERATOR_EVENT
+	operator Event() const;
+#endif
 };
 
 class ResumeResponse : public StatusInfoResponse {
@@ -420,18 +359,11 @@ public:
 		type = RESUMERESPONSE;
 	}
 	ResumeResponse(const StatusInfoResponse& father) : StatusInfoResponse(father) {}
-	static ResumeResponse fromXML(Arabica::DOM::Node<std::string> node,
-	                              InterpreterImpl* interpreter = NULL) {
-		ResumeResponse event = StatusInfoResponse::fromXML(node, interpreter);
-		event.type = RESUMERESPONSE;
-		return event;
-	}
-	operator Event() const {
-		Event ev = StatusInfoResponse::operator Event();
-		ev.setName("mmi.resumeresponse");
-		ev.setDOM(toXML());
-		return ev;
-	}
+	static ResumeResponse fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
+	
+#ifdef MMI_WITH_OPERATOR_EVENT
+	operator Event() const;
+#endif
 };
 
 class ClearContextResponse : public StatusInfoResponse {
@@ -441,18 +373,11 @@ public:
 		type = CLEARCONTEXTRESPONSE;
 	}
 	ClearContextResponse(const StatusInfoResponse& father) : StatusInfoResponse(father) {}
-	static ClearContextResponse fromXML(Arabica::DOM::Node<std::string> node,
-	                                    InterpreterImpl* interpreter = NULL) {
-		ClearContextResponse event = StatusInfoResponse::fromXML(node, interpreter);
-		event.type = CLEARCONTEXTRESPONSE;
-		return event;
-	}
-	operator Event() const {
-		Event ev = StatusInfoResponse::operator Event();
-		ev.setName("mmi.clearcontextresponse");
-		ev.setDOM(toXML());
-		return ev;
-	}
+	static ClearContextResponse fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
+
+#ifdef MMI_WITH_OPERATOR_EVENT
+	operator Event() const;
+#endif
 };
 
 class NewContextResponse : public StatusInfoResponse {
@@ -462,19 +387,11 @@ public:
 		type = NEWCONTEXTRESPONSE;
 	}
 	NewContextResponse(const StatusInfoResponse& father) : StatusInfoResponse(father) {}
-	static NewContextResponse fromXML(Arabica::DOM::Node<std::string> node,
-	                                  InterpreterImpl* interpreter = NULL) {
-		NewContextResponse event = StatusInfoResponse::fromXML(node, interpreter);
-		event.type = NEWCONTEXTRESPONSE;
-		return event;
-	}
-	operator Event() const {
-		Event ev = StatusInfoResponse::operator Event();
-		ev.setName("mmi.newcontextresponse");
-		ev.setDOM(toXML());
-		return ev;
-	}
+	static NewContextResponse fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
 
+#ifdef MMI_WITH_OPERATOR_EVENT
+	operator Event() const;
+#endif
 };
 
 class DoneNotification : public StatusInfoResponse {
@@ -484,18 +401,11 @@ public:
 		type = DONENOTIFICATION;
 	}
 	DoneNotification(const StatusInfoResponse& father) : StatusInfoResponse(father) {}
-	static DoneNotification fromXML(Arabica::DOM::Node<std::string> node,
-	                                InterpreterImpl* interpreter = NULL) {
-		DoneNotification event = StatusInfoResponse::fromXML(node, interpreter);
-		event.type = DONENOTIFICATION;
-		return event;
-	}
-	operator Event() const {
-		Event ev = StatusInfoResponse::operator Event();
-		ev.setName("mmi.donenotification");
-		ev.setDOM(toXML());
-		return ev;
-	}
+	static DoneNotification fromXML(Arabica::DOM::Node<std::string> node, InterpreterImpl* interpreter = NULL);
+	
+#ifdef MMI_WITH_OPERATOR_EVENT
+	operator Event() const;
+#endif
 };
 
 }