Index: dojo-release-1.3.2-src/dojox/xmpp/ChatService.js
===================================================================
--- dojo-release-1.3.2-src.orig/dojox/xmpp/ChatService.js	2010-01-04 11:09:30.000000000 +0530
+++ dojo-release-1.3.2-src/dojox/xmpp/ChatService.js	2010-01-04 11:09:32.000000000 +0530
@@ -63,7 +63,7 @@
 	},
 
 
-	sendMessage: function(msg){
+	sendMessage: function(msg, type){
 		if (!this.uid){
 			//console.log("ChatService::sendMessage() -  Contact Id is null, need to invite to chat");
 			return;
@@ -71,11 +71,16 @@
 
 		if ((!msg.body || msg.body=="") && !msg.xhtml){return;}
 
+        var msgType = "chat";
+        if(type){
+            msgType = type;
+        }
+
 		var req = {
 			xmlns: "jabber:client",
 			to: this.uid,
 			from: this.session.jid + "/" + this.session.resource,
-			type: "chat"
+			type: msgType
 		}
 
 		var message = new dojox.string.Builder(dojox.xmpp.util.createElement("message",req,false));
@@ -93,9 +98,9 @@
 			}
 		}
 */
-		if (message.subject && message.subject != ""){
+		if (msg.subject){
 			message.append(dojox.xmpp.util.createElement("subject",{},false));
-			message.append(message.subject);
+			message.append(msg.subject);
 			message.append("</subject>");
 		}
 		message.append(bodyPlainTag);
Index: dojo-release-1.3.2-src/dojox/xmpp/MUCManager.js
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ dojo-release-1.3.2-src/dojox/xmpp/MUCManager.js	2010-01-27 19:26:26.000000000 +0530
@@ -0,0 +1,521 @@
+dojo.provide("dojox.xmpp.MUCManager");
+dojo.require("dojox.xmpp.MUCService");
+dojo.require("dojox.xmpp._MUCAdminService");
+
+dojox.xmpp.muc = {
+    MUC_NS: "http://jabber.org/protocol/muc",
+    MUC_USER_NS: "http://jabber.org/protocol/muc#user",
+    MUC_ADMIN_NS: "http://jabber.org/protocol/muc#admin",
+    MUC_OWNER_NS: "http://jabber.org/protocol/muc#owner",
+    ROOM_USER_NS: "x-roomuser-item",
+    ROOM_NAME_NS: "muc#roomconfig_roomname",
+    ROOM_DESC_NS: "muc#roomconfig_roomdesc",
+    PERSIST_ROOM_NS: "muc#roomconfig_persistentroom",
+    MOD_ROOM_NS: "muc#roomconfig_moderatedroom",
+    MEMBERS_ONLY_NS: "muc#roomconfig_membersonly",
+    PUB_ROOM_NS: "muc#roomconfig_public",
+    DIST_ROOM_NS: "muc#roomconfig_distributedroom",
+    ROOM_LANG_NS: "muc#roomconfig_lang",
+    ROOM_EMAIL_NS: "muc#roomconfig_email",
+    CHANGE_SUBJ_NS: "muc#roomconfig_changesubject",
+    ALLOW_INVITES_NS: "muc#roomconfig_allowinvites",
+    ROOM_PWD_PROTECT_NS: "muc#roomconfig_passwordprotectedroom",
+    ROOM_PWD_NS: "muc#roomconfig_roomsecret",
+	CUSTOM_ERR_CODES: {
+		ROOM_CREATION_FAILED_NAME_CONFLICT:402,
+		ROOM_CREATION_FAILED: 400,
+		SUCCESS:200,
+		ROOM_DESTROY_FAILED:400
+	},
+	AFFILIATIONS : {
+		OWNER: "owner",
+		ADMIN: "admin",
+		MEMBER: "member",
+		OUTCAST: "outcast",
+		NONE: "none"
+	},
+	ROLES : {
+		MODERATOR: "moderator",
+		NONE: "none",
+		PARTICIPANT: "participant",
+		VISITOR: "visitor"
+	}
+}
+
+dojo.declare("dojox.xmpp.MUCManager",'',{
+    xmppSession : null,
+    mucService : "", //identitiy of mucService    
+
+	constructor: function(/* xmppSession */ session){
+		this.xmppSession = session;
+	},
+     
+    _setMUCService : function(service){
+		 // summary:
+		 //		Sets the identity of the muc-service.
+		 //		Called by xmppSession after it discovers
+		 //		the capabilities of the server
+		 //
+		 // service:
+		 //		string - id of the muc component
+		 //
+        if(!this.mucService && service){
+            this.mucService = service;
+            //console.log("setting MUC service jid as: "+this.mucService);
+        }
+    },    
+
+    _setXMPPSession : function(session){
+        this.xmppSession = session;
+    },
+
+    getMUCInstance : function(room){
+        if(this.xmppSession == null){
+            console.error("MUCManager::getMUCInstance()::No xmppSession set");
+            return;
+        }
+        var instances = this.xmppSession.chatRegister;
+        for(var i=0; i<instances.length; i++){
+            if(instances[i].uid.toLowerCase() == room.toLowerCase()){
+                return instances[i];
+            }
+        }
+        return;
+    },
+
+	getReservedRoomNickName: function(room){
+    	 // summary:
+         // 	As per 7.12 of XEP-0045 (http://xmpp.org/extensions/xep-0045.html),
+         // 	A user MAY have a reserved room nickname, for example through explicit room
+         // 	registration, database integration, or nickname "lockdown". A user SHOULD
+         // 	discover his or her reserved nickname before attempting to enter the room.
+         // 	This is done by sending a Service Discovery information request to the room JID
+         // 	while specifying a well-known Service Discovery node of "x-roomuser-item".
+         //
+    	 // room:
+    	 // 	String - fqdn of the room
+         //
+        if(!room || room==''){
+            throw new Error("MUCService::getReservedRoomNickName::room is NULL");
+        }
+
+        var node = MUCManager.ROOM_USER_NS;
+        var xmlns = "http://jabber.org/protocol/disco#info";
+        var req = {
+            to:room,
+            id:this.xmppSession.getNextIqId(),
+            from: this.xmppSession.jid + '/' + this.xmppSession.resource,
+            type: "get"
+        }
+        var request = new dojox.string.Builder(dojox.xmpp.util.createElement("iq", req, false));
+        request.append(dojox.xmpp.util.createElement("query",{
+            xmlns:xmlns,
+            node:node
+        },true));
+        request.append("</iq>");
+		var deferred = new dojo.Deferred();
+        var def = this.xmppSession.dispatchPacket(req,"iq", req.id);
+        def.addCallback(this, function(msg){
+            var nick = "";
+            if ((msg.getAttribute('type')=='result') && msg.hasChildNodes()){
+                var qnode = msg.getElementsByTagName('query')[0];
+                for (var i=0;i<qnode.childNodes.length;i++){
+                    if (qnode.childNodes[i].nodeName=="identity" && qnode.childNodes[i].getAttribute('category') == 'conference'){
+                        nick = qnode.childNodes[i].getAttribute('name');
+                        break;
+                    }
+                }
+				deferred.callback(nick);
+            }else {
+                deferred.errback(nick);
+            }            
+        });
+		return deferred;
+    },
+
+    retrieveRooms : function(){
+		 // summary:
+		 //		Uses xmpp disco to retrieve all rooms from the
+		 //		server and stores it as a MUCRoom object in
+		 //		an associative array called mucRooms with
+		 //		the jid of the room as the key.
+		 //
+		 //	associated event:
+		 //		this.onRetrieveRooms
+		 //
+		 //	returns:
+		 //		void
+		var mucRooms = [];
+        var props={
+            id: this.xmppSession.getNextIqId(),
+            from: this.xmppSession.jid + '/' + this.xmppSession.resource,
+            type: "get",
+            to: this.mucService
+        }
+        var xmlns = "http://jabber.org/protocol/disco#items";
+        var req = new dojox.string.Builder(dojox.xmpp.util.createElement("iq",props,false));
+        req.append(dojox.xmpp.util.createElement("query",{
+            xmlns:xmlns
+        },true));
+        req.append("</iq>");
+        var def = this.xmppSession.dispatchPacket(req.toString(),"iq",props.id);
+        def.addCallback(this, function(msg){            
+            if ((msg.getAttribute('type')=='result') && msg.hasChildNodes()){
+                var qnode = msg.getElementsByTagName('query')[0];
+                var itemNode, roomInstance;
+                for (var i=0;i<qnode.childNodes.length;i++){
+                    if (qnode.childNodes[i].nodeName=="item"){
+                        itemNode = qnode.childNodes[i];
+                        roomInstance = new dojox.xmpp.MUCRoom();
+                        roomInstance.jid = itemNode.getAttribute('jid');
+                        roomInstance.name = itemNode.getAttribute('name');
+                        mucRooms.push(roomInstance);
+                    }
+                }
+            }else if(msg.getAttribute('type')=="error"){
+                console.error("MUCManager::retrieveRooms()  Error recieved while getting rooms");
+            }
+            this.onRetrieveRooms(mucRooms);
+        });
+    },    
+	
+    leaveRoom : function(room){
+		// summary:
+		//			Sends presence stanza to exit a room
+		//
+		// room:
+		//			the fqdn of the room
+		//
+		// returns:
+		//			void
+        var mucInstance = this.getMUCInstance(room);
+        if(!mucInstance){
+            //console.log("MUCManager::leaveRoom()::No MUCService instance present for "+room);
+            return;
+        }
+        mucInstance.leaveRoom();
+        //var ind = this.xmppSession.chatRegister.indexOf(mucInstance);
+		var ind = dojo.indexOf(this.xmppSession.chatRegister, mucInstance);
+        if(ind >= 0) this.xmppSession.chatRegister.splice(ind,1);
+    },
+
+    _handlePresence : function(msg){
+        if(this.xmppSession == null){
+            console.error("MUCManager::handlePresence()::No xmppSession set");
+            return;
+        }
+        var room = this.xmppSession.getBareJid(msg.getAttribute('from'));
+        var mucInstance = this.getMUCInstance(room);
+        // response from createRoom presence request
+        if(!mucInstance && this.roomInCreateMode){
+            mucInstance = this.roomInCreateMode;
+			mucInstance._initRoster(msg);
+            mucInstance._handleCreateRoom(msg);
+            return;
+        }
+        if(!mucInstance){
+            //console.log("MUCManager::handlePresence()::No MUCService instance present for "+room);
+            return;
+        }
+        if(!mucInstance.rosterRetrieved){
+            mucInstance._initRoster(msg);
+        }else {
+            mucInstance._updateRoster(msg);
+        }
+    },
+
+	declineInvitation: function(invitation){
+		// summary:
+		//			Sends a message stanza to decline an invitation
+		//
+		// room:
+		//			the dojox.xmpp.MUCInvitation object
+		//
+		// returns:
+		//
+		if(!invitation.from || !invitation.room){
+			console.error("MUCManager::declineInvitation()::Invalid invitation object");
+		}
+		var to = invitation.from;
+		var room = invitation.room;
+		var reason = invitation.reason;
+
+		var m = {
+            to:room,
+            from:this.xmppSession.jid + "/" + this.xmppSession.resource
+        };
+        var req = new dojox.string.Builder(dojox.xmpp.util.createElement("message", m, false));
+        req.append(dojox.xmpp.util.createElement("x",{
+            xmlns:dojox.xmpp.muc.MUC_USER_NS
+        },false));
+        req.append(dojox.xmpp.util.createElement("decline",{
+            to:to
+        },false));
+        req.append(dojox.xmpp.util.createElement("reason",{},false));
+        req.append(dojox.xmpp.util.stripHtml(reason));
+        req.append("</reason></decline></x>");
+        req.append("</message>");
+        var def = this.xmppSession.dispatchPacket(req.toString());
+	},
+
+    _handleMUCSimpleMessage : function(msg){
+        var room = this.xmppSession.getBareJid(msg.getAttribute('from'));        
+        if(msg.getElementsByTagName("invite")[0]){
+            this._processInvite(msg);
+        }else if(msg.getElementsByTagName("decline")[0]){
+            this._processDecline(msg);
+        }
+    },
+
+    _processInvite : function(msg){
+        var room = msg.getAttribute('from');
+        var inNode = msg.getElementsByTagName("invite")[0];
+        if(!inNode || !inNode.getAttribute('from')) return;
+        var from = this.xmppSession.getBareJid(inNode.getAttribute('from'));
+        var rNode = inNode.getElementsByTagName("reason")[0];
+        var reason = "";
+        if(rNode) reason = rNode.textContent;
+        var invite = new dojox.xmpp.MUCInvitation();
+        invite.from = from;
+        invite.room = room;
+        invite.reason = reason;
+        this.onInvitation(invite);
+    },
+
+	_processDecline : function(msg){
+        var room = msg.getAttribute('from');
+        var inNode = msg.getElementsByTagName("decline")[0];
+        if(!inNode || !inNode.getAttribute('from')) return;
+        var from = this.xmppSession.getBareJid(inNode.getAttribute('from'));
+        var rNode = inNode.getElementsByTagName("reason")[0];
+        var reason = "";
+        if(rNode) reason = rNode.textContent;
+        var invite = new dojox.xmpp.MUCInvitation();
+        invite.from = from;
+        invite.room = room;
+        invite.reason = reason;
+		var instance = this.getMUCInstance(room);
+		if(instance){
+			instance.onInvitationDeclined(invite);
+		}
+    },
+	
+    createRoom : function(nickname, roomCfg){
+		// summary:
+		//		Creates a reserved room as specified in section 10.1.3 of xep-0045
+		//		Outline of steps to create a room:
+		//		1. Check if the room exists
+		//		2. Send presence to the room
+		//		3. Send IQ with MUC owner NS
+		//		4. Fill the configuration form and send to server
+		//		If, at any point there is a failure or in case of success
+		//		an event is fired to mark the end of creation process
+		//		Response code is set in the roomCfg object
+		//
+		// nickname:
+		//			Nickname to be used when creating this room
+		// mucService:
+		//			dojox.xmpp.MUCService object for this room
+		// roomCfg:
+		//			dojox.xmpp.MUCRoomConfig object for this room
+		//
+		// associated event:
+		//			this.onCreateRoom
+		//
+		// returns:
+		//			void
+		var roomId = roomCfg.roomId;
+        var admSrvc = new dojox.xmpp._MUCAdminService(this.xmppSession);
+		var mucService = new dojox.xmpp.MUCService(roomId, nickname);
+		mucService.setSession(this.xmppSession);
+		admSrvc.setMUCManager(this);
+        this.roomInCreateMode = mucService;
+		var def = admSrvc.createRoom(mucService, roomCfg);
+		def.addBoth(this, "_onCreateRoom");
+        return def;
+    },
+	
+	createInstantRoom : function(nickname, roomCfg){
+		// summary:
+		//			Creates an instant room as specified in section 10.1.2
+		//			of XEP-0045. Requests for a unique id from the server
+		//			and uses this as the name of the room.
+		// nickname:
+		//			Nickname to be used when creating this room
+		// mucService:
+		//			dojox.xmpp.MUCService object for this room
+		// roomCfg:
+		//			dojox.xmpp.MUCRoomConfig object for this room
+		//
+		// associated event:
+		//			this.onCreateRoom
+		//
+		// returns:
+		//			void
+		var roomId = roomCfg.roomId;
+		var mucService = new dojox.xmpp.MUCService(roomId, nickname);
+		mucService.setSession(this.xmppSession);
+        var admSrvc = new dojox.xmpp._MUCAdminService(this.xmppSession);		
+		admSrvc.setMUCManager(this);
+        this.roomInCreateMode = mucService;
+        var def = admSrvc.createInstantRoom(mucService, roomCfg);
+		def.addBoth(this, "_onCreateRoom");
+        return def;
+    },
+	
+	getUniqueName: function() {
+		// summary:
+		//			Sends iq stanza to request for a unique name as specified in
+		//			section 10.1.4 of xep-0045
+		//
+		// returns:
+		//			deferred				
+    	var props={
+                id: this.xmppSession.getNextIqId(),
+                from: this.xmppSession.jid + '/' + this.xmppSession.resource,
+                type: "get",
+                to: this.mucService
+            }
+        var xmlns = "http://jabber.org/protocol/muc#unique";
+        var req = new dojox.string.Builder(dojox.xmpp.util.createElement("iq",props,false));
+        req.append(dojox.xmpp.util.createElement("unique",{
+            xmlns:xmlns
+        },true));
+        req.append("</iq>");
+		var deferred = new dojo.Deferred();
+        var def = this.xmppSession.dispatchPacket(req.toString(),"iq",props.id);
+        def.addCallback(this, function(msg){
+        	var uniqueId = "";
+        	if(msg.getAttribute('type') == 'result'){
+        		uniqueId = msg.getElementsByTagName('unique')[0].firstChild.nodeValue;
+				deferred.callback(uniqueId);
+        	}else {
+				deferred.errback();
+			}        	
+        });
+        return deferred;
+	},
+		
+    destroyRoom : function(room /*the fqdn of room*/, reason /* why? */) {
+		// summary:
+		//			Sends iq stanza to destroy a room
+		//
+		// room:
+		//			the fqdn of the room
+		// reason:
+		//			optional string - reason to destroy this room
+		//		
+		//
+		// returns:
+		//			deferred
+        var admSrvc = new dojox.xmpp._MUCAdminService(this.xmppSession);
+		admSrvc.setMUCManager(this);
+        return admSrvc.destroyRoom(room, reason);
+    },
+
+    bookmarkRooms : function(rooms) {
+		// summary:
+		//		Use XML storage to store the given list of rooms.
+		//		The rooms are stored under the "storage:bookmarks" namespace
+		// rooms:
+		//		Array of dojox.xmpp.MUCRoom objects
+        var req = new dojox.string.Builder(dojox.xmpp.util.createElement("storage",{xmlns:"storage:bookmarks"},false));
+        var room;
+        for(var i=0;i<rooms.length;i++){
+            room = rooms[i];
+            if(!room || !room.jid || !room.name){
+                console.error("MUCManager::bookmarkRoom::invalid MUCRoom object");
+                continue;
+            }
+            var props = {
+                jid:room.jid,
+                name:room.name
+            };
+            req.append(new dojox.string.Builder(dojox.xmpp.util.createElement("conference",props,false)));
+
+            if(room.nick){
+                req.append(new dojox.string.Builder(dojox.xmpp.util.createElement("nick",{},false)));
+                req.append(room.nick);
+                req.append("</nick>");
+            }
+            req.append("</conference>");
+        }
+        req.append("</storage>");
+		var deferred = new dojo.Deferred();
+        var def = this.xmppSession.storeXML(req);
+		def.addCallback(this, function(msg){
+			if(msg.getAttribute('type') == 'result'){
+				deferred.callback();
+			}else {
+				deferred.errback();
+			}
+		});
+		return deferred;
+    },
+
+    retrieveBookmarks : function() {
+		// summary:
+		//		Retrieve list of rooms stored under the "storage:bookmarks" namespace		
+		//
+		// returns:
+		//		deferred
+        var req = new dojox.string.Builder(dojox.xmpp.util.createElement("storage",{xmlns:"storage:bookmarks"},true));
+		var deferred = new dojo.Deferred();
+        var def = this.xmppSession.retrieveXML(req);
+        def.addCallback(this, function(msg){
+			if(msg.getAttribute('type') == 'error'){
+				deferred.errback();
+			}else {
+				var confNodes = msg.getElementsByTagName('conference');
+				var conf;
+				var room, rooms = [];
+				for(var i=0;i<confNodes.length;i++){
+					conf = confNodes[i];
+					room = new dojox.xmpp.MUCRoom();
+					room.jid = conf.getAttribute('jid');
+					room.name = conf.getAttribute('name');
+					if(conf.getElementsByTagName('nick')[0]){
+						room.nick = conf.getElementsByTagName('nick')[0].firstChild.nodeValue;
+					}
+					rooms.push(room);
+				}
+				//this.onRetrieveBookmarks(rooms);
+				deferred.callback(rooms);
+			}
+        });
+		return deferred;
+    },
+    
+    _isMUC : function(msg){
+		// summary:
+		//		Check whether the stanza is from a MUC service
+		//
+		// msg:
+		//		the xmpp response
+		//
+		// returns:
+		//		boolean- true, if the stanza is from MUC
+        if(msg.nodeName == 'presence' || msg.nodeName == 'message'){
+			var xNodes = msg.getElementsByTagName('x');		
+			for(var i=0; i<xNodes.length; i++){
+			  if(xNodes[i].getAttribute('xmlns').search(dojox.xmpp.muc.MUC_NS) >= 0){
+				return true;
+			  }
+			}
+        }
+		return false;
+    },
+
+    onRetrieveRooms : function(mucRooms){},
+
+    onRegisterChatInstance : function(instance, message){
+		//console.log("MUCManager::onRegisterChatInstance: for instance "+instance.uid);
+	},
+
+    onInvitation : function(/* dojox.xmpp.MUCInvitation object */invitation){}, /* somebody sent me an invitation */
+
+    _onCreateRoom : function() { /* Room Created */
+		//console.log("Room creation complete "+roomCfg.roomId);
+        this.roomInCreateMode = null;
+    }    
+});
\ No newline at end of file
Index: dojo-release-1.3.2-src/dojox/xmpp/MUCService.js
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ dojo-release-1.3.2-src/dojox/xmpp/MUCService.js	2010-01-28 18:27:40.000000000 +0530
@@ -0,0 +1,408 @@
+dojo.provide("dojox.xmpp.MUCService");
+
+dojox.xmpp.MUCOccupant = function(){
+    this.nickName = "",
+    this.affiliation = "",
+    this.role = "",
+    this.jid = "",
+    this.presence = {
+        show:"",
+        type:"",
+        status: ""
+    }
+}
+
+dojox.xmpp.MUCRoom = function(){
+    this.jid = "",
+    this.name = "",
+    this.nick = ""
+}
+
+dojox.xmpp.MUCInvitation = function(){
+    this.from = "";
+    this.room = "";
+    this.reason = "";
+}
+
+dojo.declare("dojox.xmpp.MUCService",[dojox.xmpp.ChatService],{
+
+    nickname : "",
+    rosterRetrieved: false /* flag to mark retrieval of room roster */,
+    roster: [] /* associative array of Occupant objects identified by nickname */,
+    self: null,
+	_hasJoined: false, /* has the joinRoom been called? */
+
+    constructor: function(room, nick){
+		// summary:
+		//		creates a new instance of MUCService for this room
+		//		and uses the provided nickname
+		//
+		// room:
+		//		fqdn of the room
+		// nick:
+		// 		nickname for this room
+        this.uid = room;
+        this.nickname = nick;
+		this.roster = [];
+        //console.log("MUCService instance for "+ room +" created with nick "+nick);
+    },
+
+    joinRoom: function(extraAttrs){
+        // summary:
+        //        sends a presence stanza to join this room
+        //
+        // extraAttrs:
+        //        Extra information to be sent as part of the presence stanza
+        //        They are
+        //            history:
+        //                    name:as specified in section 7.1.16 - Managing Discussion History
+        //                         of http://xmpp.org/extensions/xep-0045.html
+        //                    value: datatype as specified in the section above
+        //                    For eg: history: { maxchars: "0" }
+        //
+
+        var room = this.uid;
+        if(this._hasJoined){ // already joined, do not fire again
+            this.onInitRoster(this.roster); // fire event for continuity
+            return;
+        }
+        this.roster = [];
+        this.rosterRetrieved = false;
+        if(!room || room==''){
+            throw new Error("MUCService::joinRoom()::room is NULL");
+        }
+
+        var p = {
+            to:room + "/" + this.nickname,
+            from:this.session.jid + '/' + this.session.resource
+        }
+        var req = new dojox.string.Builder(dojox.xmpp.util.createElement("presence",p,false));
+        req.append(dojox.xmpp.util.createElement("x",{
+            xmlns:dojox.xmpp.muc.MUC_NS
+        },false));
+        if(extraAttrs && extraAttrs.history){
+            req.append(dojox.xmpp.util.createElement("history", extraAttrs.history ,true));
+        }
+        req.append("</x>")
+        req.append("</presence>");
+        var def = this.session.dispatchPacket(req.toString());
+        this._hasJoined = true;
+    },
+
+    leaveRoom: function(){
+
+        var room = this.uid;
+        var p = {
+            to:room + "/" + this.nickname,
+            from:this.session.jid + '/' + this.session.resource,
+            type: "unavailable"
+        }
+        var req = new dojox.string.Builder(dojox.xmpp.util.createElement("presence",p,false));
+        req.append(dojox.xmpp.util.createElement("x",{
+            xmlns:dojox.xmpp.muc.MUC_NS
+        },true));
+        req.append("</presence>");
+        var def = this.session.dispatchPacket(req.toString());        
+    },
+
+    invite: function(/* userid or array of userids */to, /*Reason*/message){
+    	// summary:
+    	//		send an iq stanza to this room to invite the
+    	//		given user with the provided message
+    	//
+    	// to:
+    	//		fully qualified userid or array of userids of the invitee
+    	// message:
+    	//		String - message to be sent as part of the invitation
+        var m = {
+            to:this.uid,
+            from:this.session.jid + "/" + this.session.resource
+        };
+        var req = new dojox.string.Builder(dojox.xmpp.util.createElement("message", m, false));
+        req.append(dojox.xmpp.util.createElement("x",{
+            xmlns:dojox.xmpp.muc.MUC_USER_NS
+        },false));
+		if(dojo.isArray(to)){
+			dojo.forEach(to, function(item){
+				req.append(dojox.xmpp.util.createElement("invite",{
+					to:item
+				},false));
+				req.append(dojox.xmpp.util.createElement("reason",{},false));
+				req.append(dojox.xmpp.util.stripHtml(message));
+				req.append("</reason></invite>");
+			});
+		}else {
+			req.append(dojox.xmpp.util.createElement("invite",{
+				to:to
+			},false));
+			req.append(dojox.xmpp.util.createElement("reason",{},false));
+			req.append(dojox.xmpp.util.stripHtml(message));
+			req.append("</reason></invite>");
+			}
+			req.append("</x>");
+			req.append("</message>");
+        var def = this.session.dispatchPacket(req.toString());
+    },    
+
+    removeFromRoster: function(occ){
+        if(!this.roster || !occ) return;
+        delete this.roster[occ.nickName];
+    },        
+
+    setNickName: function(nick){
+        this.nickname = nick;
+    },
+   
+    _initRoster: function(msg){
+    	 // summary:
+         // 	Called to create the room-roster when
+         // 	a user joins a conference. A flag is set to
+         // 	mark the completion of init. All further
+         // 	updated are handled by updateRoster
+         // 
+         // msg:
+    	 // 	the xmpp response
+        if(this.rosterRetrieved){
+            console.error("MUCService::initRoster::Illegal state: initRoster called after initialization for room "+this.uid);
+            return;
+        }
+        if(msg.getAttribute('type') == 'error'){
+            this._processPresenceError(msg);
+            return;
+        }
+        var roomjid = msg.getAttribute('from');
+        var occNN = this.session.getResourceFromJid(roomjid);//occupant nick-name;
+        //console.log("MUCService for room "+this.uid+"::initRoster::Processing presence for: "+occNN);
+        this.roster[occNN] = this._processPresenceParams(msg);        
+        if(this._contains(this._getStatusCode(msg), '110') || this.nickname == occNN){ // presence of self - marking end of room roster
+			this.self = this.roster[occNN];
+			if(!this.rosterRetrieved){
+				this.onInitRoster(this.roster);
+				this.rosterRetrieved = true;
+			}            
+        }
+        if(this._contains(this._getStatusCode(msg), '210')){ // presence of self - nick rewritten by service
+            this.nickname = occNN;
+            this.onMyNickNameModified(occNN);
+        }
+    },    
+
+    _updateRoster: function(msg){
+    	// summary:
+        // 	Handle presence updates to this room
+        // 	after initializing the roster
+        //
+    	// msg:
+   	 	// 		the xmpp response
+        if(msg.getAttribute('type') == 'error'){
+            this._processPresenceError(msg);
+            return;
+        }
+        var roomjid = msg.getAttribute('from');        
+        var occNN = this.session.getResourceFromJid(roomjid);
+        var origOcc = this.roster[occNN];
+		var occ;
+		if(origOcc){
+			occ = dojo.clone(origOcc);
+		}
+        //console.log("MUCService for room "+this.uid+"::updateRoster::Processing presence for: "+occNN);
+        this.roster[occNN] = this._processPresenceParams(msg, occ);;
+        if(occNN == this.nickname){ // self presence changed
+            this.self = this.roster[occNN];
+            if(this._contains(this._getStatusCode(msg), '307')){ // I am kicked!
+                this.onKicked();
+                return;
+            }
+            if(this._contains(this._getStatusCode(msg), '301')){ // I am banned!
+                this.onBanned();
+                return;
+            }
+            this.onMyPresenceChanged();
+            return;            
+        }
+        if(this._contains(this._getStatusCode(msg), '303')){// occupant's nick-name changed
+            this.onNickNameChanged(occNN);
+            return;
+        }
+        this.onUpdateRoster(/*nickname*/occNN, /*original state*/origOcc);
+    },
+    
+    getSelfOccupancy: function(){
+    	// summary:
+        // 		Returns the Occupant object for self
+        //
+        return this.self;
+    },
+    
+    hasVoice: function() {
+    	// summary:
+        // 		Determines if self can speak or not in this room
+        //         
+        if(!this.self) return false;
+        var role = this.self.role;
+        if(role == dojox.xmpp.muc.ROLES.NONE || role == dojox.xmpp.muc.ROLES.VISITOR)
+            return false;
+        return true;
+    },
+
+	isOwner: function() {
+		// summary:
+        // 		Determines if self is the owner of this room
+        //
+		if(!this.self) return false;
+        var affiliation = this.self.affiliation;
+        if(affiliation == dojox.xmpp.muc.AFFILIATIONS.OWNER)
+            return true;
+        return false;
+	},
+
+	kick: function(nickname, reason) {
+		// summary:
+        // 		Kicks an occupant out of this room
+        //
+		// nickname:
+	 	//		string nickname of the occupant to be kicked
+		// reason:
+		//		optional string reason to kick the occupant		
+        var props={
+            id: this.session.getNextIqId(),
+            from: this.session.jid + '/' + this.session.resource,
+            type: "set",
+            to: this.uid
+        }
+        var props1 = {
+            xmlns:dojox.xmpp.muc.MUC_ADMIN_NS
+        }
+        var req = new dojox.string.Builder(dojox.xmpp.util.createElement("iq",props,false));
+		req.append(new dojox.string.Builder(dojox.xmpp.util.createElement("query",props1,false)));
+		req.append(new dojox.string.Builder(dojox.xmpp.util.createElement("item",{nick:nickname, role:dojox.xmpp.muc.ROLES.NONE}, false)));
+		if(reason){
+			req.append("<reason>");
+            req.append(dojox.xmpp.util.stripHtml(reason));
+            req.append("</reason>");
+		}
+		req.append("</item></query></iq>");
+		var deferred = new dojo.Deferred();
+		var def = this.session.dispatchPacket(req.toString(),"iq",props.id);
+        def.addCallback(this, function(msg){
+			if(msg.getAttribute('type') == 'result'){
+				deferred.callback();
+			}else {
+				deferred.errback();
+			}
+		});
+		return deferred;
+	},
+    _handleCreateRoom: function(msg){
+    	// summary:
+        // 		Called by MUCManager.createRoom
+        // 		as part of the call to create a room
+        // msg:
+        //		the xmpp response
+        if(msg.getAttribute('type') == 'error'){
+            this._processPresenceError(msg);
+            return;
+        }else {			
+            this.onRoomCreate(this.uid);
+        }
+    },
+
+    _processPresenceParams: function(msg, occ){
+        var roomjid = msg.getAttribute('from');
+        var occNN = this.session.getResourceFromJid(roomjid);
+		if(!occ)
+			occ = new dojox.xmpp.MUCOccupant();
+        occ.nickName = occNN;
+        if(msg.getAttribute('type')) occ.presence.type = msg.getAttribute('type');        
+        for (var i=0; i<msg.childNodes.length; i++){
+            var node = msg.childNodes[i];
+            if(node.nodeName.toString() == 'x'){
+                if(node.getAttribute('xmlns') == dojox.xmpp.muc.MUC_USER_NS || node.getAttribute('xmlns') == dojox.xmpp.muc.MUC_NS){
+                    this._processExtendedPresenceParams(node, occ);                    
+                }
+            } else if(node.nodeName.toString() == 'show'){
+				if(node.textContent) occ.presence.show = node.textContent;
+            } else if(node.nodeName.toString() == 'status'){
+               if(node.textContent) occ.presence.status = node.textContent;
+            } else {
+                // do nothing
+            }
+        }
+        return occ;
+    },
+
+    _processExtendedPresenceParams: function(/* the x node*/ n, /* Occupant object */ occ) {
+        for (var i=0; i<n.childNodes.length; i++){
+            var node = n.childNodes[i];
+            if(node.nodeName.toString() == 'item'){
+                if(node.getAttribute('affiliation')) occ.affiliation = node.getAttribute('affiliation');
+                if(node.getAttribute('role')) occ.role = node.getAttribute('role');
+                if(node.getAttribute('jid')) occ.jid = node.getAttribute('jid');
+                if(node.getAttribute('nick')) occ.nickName = node.getAttribute('nick');
+            }            
+        }
+    },
+
+     _getStatusCode: function(/* the presence or x node*/n) {
+        var codes = [];
+        var nodes;
+        if(n.nodeName == 'x' || n.nodeName == 'presence'){
+            nodes = n.getElementsByTagName('status');
+            var ind = 0;
+            for(var i=0;i<nodes.length;i++){
+                codes[ind] = nodes[i].getAttribute('code');
+                ind = ind+1;
+            }
+            return codes;
+        }
+    },
+
+    _processPresenceError: function(msg) {
+        //nick empty
+        //nick conflict
+        //nick locked-down
+        var err = this.session.processXmppError(msg);
+        this.onPresenceError(err);        
+    },
+
+    _contains: function(/*array*/a, /*value*/v) {         
+        if(!a || !v) return false;
+        for(var i=0; i<a.length; i++){
+            if(a[i] == v) return true;
+        }
+        return false;
+    },
+
+    // Events
+
+    onUpdateRoster: function(/* nickname */nickName, /* original state-Occupant object */occupant){},
+    
+    onInitRoster: function(roster){
+        //console.log("Roster init complete for room "+this.uid);		
+    },
+
+    onMyNickNameModified: function(nickName){},
+
+    onMyPresenceChanged: function() {},
+
+    onNickNameChanged: function(/* old nickname */oldNickName) {},
+
+    onKicked: function(){} /* I am kicked by the moderator*/,
+
+    onBanned: function(){}/* I am banned by the moderator*/,
+
+    onRoomNickRetrieved: function(nick){} /* Reserved room-nickname retrieved */,
+
+    onPresenceError: function(err){} /* Error occured in Presence stanza*/,
+
+    onRoomCreate: function(room){  /*  Room Creation was successful */
+		//console.log("onRoomCreate for room "+room)
+	},
+
+	onInvitationDeclined : function(/* dojox.xmpp.MUCInvitation object*/invitation){}, /* somebody declined my invitation */
+
+    last : ""
+    
+})
+
+
Index: dojo-release-1.3.2-src/dojox/xmpp/_MUCAdminService.js
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ dojo-release-1.3.2-src/dojox/xmpp/_MUCAdminService.js	2010-01-04 11:09:32.000000000 +0530
@@ -0,0 +1,347 @@
+dojo.provide('dojox.xmpp._MUCAdminService');
+dojo.require('dojox.xml.parser');
+
+dojox.xmpp.MUCRoomConfig = function(){
+    this.roomId = "";
+    this.roomName = "";
+    this.roomDesc = "";
+    this.isPersistent = true;
+    this.isModerated = false;
+    this.isPublic = true;
+    this.isMembersOnly = false;
+    this.isDistributed = false;
+    this.lang = "";
+    this.email = "";
+    this.allowChangeSubject = true;
+    this.allowInvites = true;
+    this.isPasswordProtected = false;
+    this.password = "";
+    // Response Codes:-
+    // Success - 200; Room already present - 402; Room not found - 401; Other - 400;
+    this.responseCode = "";
+}
+
+dojo.declare("dojox.xmpp._MUCAdminService",'',{
+
+    xmppSession: null,
+    mgr: null,
+    cfgVals : [],
+    
+    constructor: function(session /* dojox.xmpp.xmppSession object */){
+        this.xmppSession = session;
+    },
+
+	setMUCManager: function(mucManager){
+		this.mgr = mucManager;
+	},
+      
+    isRoomPresent: function(roomCfg){
+		 // summary:
+		 //		Sends an iq stanza with disco#info query
+		 //		to the roomId specified to check if the
+		 //		room exists
+		 //	roomCfg:
+		 //		dojox.xmpp.MUCRoomConfig object
+		 //
+		 // returns:
+		 //		deferred object
+        if(!roomCfg.roomId){
+            console.error("_MUCAdminService::isRoomPresent::No name specified for room");
+            return;
+        }        
+        var props={
+            id: this.xmppSession.getNextIqId(),
+            from: this.xmppSession.jid + '/' + this.xmppSession.resource,
+            type: "get",
+            to: roomCfg.roomId
+        }
+        var xmlns = "http://jabber.org/protocol/disco#info";
+        var req = new dojox.string.Builder(dojox.xmpp.util.createElement("iq",props,false));
+        req.append(dojox.xmpp.util.createElement("query",{
+            xmlns:xmlns            
+        },true));
+        req.append("</iq>");
+        var def = this.xmppSession.dispatchPacket(req.toString(),"iq",props.id);
+        return def;
+    },
+
+	
+    createRoom: function(mucService, roomCfg){
+		// summary:
+		//		Creates a reserved room as specified in section 10.1.3 of xep-0045
+		//		Outline of steps to create a room:
+		//		1. Check if the room exists
+		//		2. Send presence to the room
+		//		3. Send IQ with MUC owner NS
+		//		4. Fill the configuration form and send to server
+		//		If, at any point there is a failure or in case of success
+		//		an event is fired to mark the end of creation process
+		//		Response code is set in the roomCfg object
+		//
+		// nickname:
+		//			Nickname to be used when creating this room
+		// mucService:
+		//			dojox.xmpp.MUCService object for this room
+		// roomCfg:
+		//			dojox.xmpp.MUCRoomConfig object for this room
+		//
+		// associated event:
+		//			MUCManager.onCreateRoom
+		//
+		// returns:
+		//			void
+        var def = this.isRoomPresent(roomCfg);
+        var self = this;
+		var connects = [];
+		var deferred = new dojo.Deferred();
+        def.addCallback(this, function(msg){
+            var isPresent;
+            // if room-name is not present continue with room creation steps
+            if(msg.getAttribute('type') == 'error'){
+                isPresent = false;
+            }else {
+                isPresent = true;
+            }            
+            if(!isPresent){
+                var c1 = dojo.connect(mucService,"onRoomCreate", function(){
+                    // first step successful.... continue
+                    var props={
+                        id: self.xmppSession.getNextIqId(),
+                        from: self.xmppSession.jid + '/' + self.xmppSession.resource,
+                        type: "get",
+                        to: roomCfg.roomId
+                    }
+                    var req = new dojox.string.Builder(dojox.xmpp.util.createElement("iq",props,false));
+                    req.append(dojox.xmpp.util.createElement("query",{
+                        xmlns:dojox.xmpp.muc.MUC_OWNER_NS
+                    },true));
+                    req.append("</iq>");
+					self._doDisconnects(connects);
+                    var def = self.xmppSession.dispatchPacket(req.toString(),"iq",props.id);
+                    def.addCallback(self, function(msg){
+                        var def1 = self._processCreateConfig(msg, roomCfg);
+						def1.addCallback(function(roomCfg){
+							var resp = {};
+							resp.mucService = mucService;
+							resp.roomCfg = roomCfg;
+							deferred.callback(resp);
+						}).addErrback(function(errCode){
+							deferred.errback(errCode);
+						});
+                    });					
+                });
+				connects.push(c1);
+                var c2 = dojo.connect(mucService,"_processPresenceError", function(msg){
+                    // failed, notify end of creation
+                    roomCfg.responseCode = dojox.xmpp.muc.CUSTOM_ERR_CODES.ROOM_CREATION_FAILED;
+					self._doDisconnects(connects);
+                    //self.mgr.onCreateRoom(roomCfg);
+					deferred.errback(dojox.xmpp.muc.CUSTOM_ERR_CODES.CUSTOM_ERR_CODES.ROOM_CREATION_FAILED);
+                });
+				connects.push(c2);
+                // send presence to the new room-name to start room creation
+                mucService.joinRoom();
+            }else {
+                // notify that creation process is over
+                roomCfg.responseCode = dojox.xmpp.muc.CUSTOM_ERR_CODES.ROOM_CREATION_FAILED_NAME_CONFLICT;
+                //this.mgr.onCreateRoom(roomCfg);
+				deferred.errback(dojox.xmpp.muc.CUSTOM_ERR_CODES.ROOM_CREATION_FAILED_NAME_CONFLICT);
+            }
+        });
+		return deferred;
+    },
+	
+	createInstantRoom: function(mucService, roomCfg){
+		// summary:
+		//			Creates an instant room as specified in section 10.1.2
+		//			of XEP-0045. Requests for a unique id from the server
+		//			and uses this as the name of the room.
+		// nickname:
+		//			Nickname to be used when creating this room
+		// mucService:
+		//			dojox.xmpp.MUCService object for this room
+		// roomCfg:
+		//			dojox.xmpp.MUCRoomConfig object for this room
+		//
+		// associated event:
+		//			MUCManager.onCreateRoom
+		//
+		// returns:
+		//			void
+		var roomId = roomCfg.roomId;		
+		var self = this;
+		var connects = [];
+		var deferred = new dojo.Deferred();
+		var c1 = dojo.connect(mucService,"onRoomCreate", function(){
+			// first step successful.... continue
+			var props={
+				id: self.xmppSession.getNextIqId(),
+				from: self.xmppSession.jid + '/' + self.xmppSession.resource,
+				type: "set",
+				to: roomId
+			}
+			var req = new dojox.string.Builder(dojox.xmpp.util.createElement("iq",props,false));
+			req.append(dojox.xmpp.util.createElement("query",{
+				xmlns:dojox.xmpp.muc.MUC_OWNER_NS
+			},false));
+			req.append(dojox.xmpp.util.createElement("x",{
+				xmlns:"jabber:x:data", type:"submit"
+			},true));
+			req.append("</query>");
+			req.append("</iq>");
+			var def = self.xmppSession.dispatchPacket(req.toString(),"iq",props.id);
+			def.addCallback(self, function(msg){
+				if(msg.getAttribute('type') == 'result'){
+					var resp = {};
+					resp.mucService = mucService;
+					resp.roomCfg = roomCfg;
+					deferred.callback(resp);
+				}else {
+					//roomCfg.responseCode = dojox.xmpp.muc.CUSTOM_ERR_CODES.ROOM_CREATION_FAILED;
+					deferred.errback(dojox.xmpp.muc.CUSTOM_ERR_CODES.ROOM_CREATION_FAILED);
+				}
+				self._doDisconnects(connects);
+				//this.mgr.onCreateRoom(roomCfg, mucService);
+			});
+		});
+		connects.push(c1);
+		var c2 = dojo.connect(mucService,"_processPresenceError", function(msg){
+			// failed, notify end of creation
+			//roomCfg.responseCode = dojox.xmpp.muc.CUSTOM_ERR_CODES.ROOM_CREATION_FAILED;
+			self._doDisconnects(connects);
+			deferred.errback(dojox.xmpp.muc.CUSTOM_ERR_CODES.ROOM_CREATION_FAILED);
+			//self.mgr.onCreateRoom(roomCfg);
+		});
+		connects.push(c2);
+		// send presence to the new room-name to start room creation
+		mucService.joinRoom();
+		return deferred;
+	},
+
+    destroyRoom: function(room/* roomname */, reason /* message */){        
+        var props={
+            id: this.xmppSession.getNextIqId(),
+            from: this.xmppSession.jid + '/' + this.xmppSession.resource,
+            type: "set",
+            to: room
+        }
+        var props1 = {
+            xmlns:dojox.xmpp.muc.MUC_OWNER_NS
+        }
+        var req = new dojox.string.Builder(dojox.xmpp.util.createElement("iq",props,false));
+        req.append(new dojox.string.Builder(dojox.xmpp.util.createElement("query",props1,false)));
+        req.append(new dojox.string.Builder(dojox.xmpp.util.createElement("destroy",{jid:props.from},false)));
+        if(reason){
+            req.append(dojox.xmpp.util.createElement("reason",{},false));
+            req.append(dojox.xmpp.util.stripHtml(reason));
+            req.append("</reason>");
+        }
+        req.append("</destroy></query></iq>");
+		var deferred = new dojo.Deferred();
+        var def = this.xmppSession.dispatchPacket(req.toString(),"iq",props.id);
+        def.addCallback(this, function(msg){
+            if(msg.getAttribute('type') == 'result'){                
+				deferred.callback(room);
+            }else {                
+				deferred.errback();
+            }            
+        });
+		return deferred;
+
+    },
+
+    _processCreateConfig: function(msg, roomCfg){
+        // process the create-room config here
+        // fill the form and send to server               
+        this._setValueIntoCfgForm(dojox.xmpp.muc.ROOM_NAME_NS, roomCfg.roomName);
+        this._setValueIntoCfgForm(dojox.xmpp.muc.ROOM_DESC_NS, roomCfg.roomDesc);
+        this._setValueIntoCfgForm(dojox.xmpp.muc.PERSIST_ROOM_NS, roomCfg.isPersistent);
+        this._setValueIntoCfgForm(dojox.xmpp.muc.MOD_ROOM_NS, roomCfg.isModerated);
+        this._setValueIntoCfgForm(dojox.xmpp.muc.MEMBERS_ONLY_NS, roomCfg.isMembersOnly);
+        this._setValueIntoCfgForm(dojox.xmpp.muc.PUB_ROOM_NS, roomCfg.isPublic);
+        this._setValueIntoCfgForm(dojox.xmpp.muc.DIST_ROOM_NS, roomCfg.isDistributed);
+        this._setValueIntoCfgForm(dojox.xmpp.muc.ROOM_EMAIL_NS, roomCfg.email);
+        this._setValueIntoCfgForm(dojox.xmpp.muc.CHANGE_SUBJ_NS, roomCfg.allowChangeSubject);
+        this._setValueIntoCfgForm(dojox.xmpp.muc.ROOM_LANG_NS, roomCfg.lang);
+        this._setValueIntoCfgForm(dojox.xmpp.muc.ALLOW_INVITES_NS, roomCfg.allowInvites);
+        this._setValueIntoCfgForm(dojox.xmpp.muc.ROOM_PWD_PROTECT_NS, roomCfg.isPasswordProtected);
+        this._setValueIntoCfgForm(dojox.xmpp.muc.ROOM_PWD_NS, roomCfg.password);
+
+		var deferred = new dojo.Deferred();
+
+		var xNodes = msg.getElementsByTagName('x');
+		var xNode = null;
+		for(var i=0; i<xNodes.length; i++){
+		  if(xNodes[i].getAttribute('xmlns') == 'jabber:x:data'){
+			xNode = xNodes[i];
+			xNode.removeAttribute("type");
+			xNode.setAttribute("type", "submit");
+		  }
+		}
+
+		this._setValueIntoCfgForm1(xNode);
+
+        var props={
+            id: this.xmppSession.getNextIqId(),
+            from: this.xmppSession.jid + '/' + this.xmppSession.resource,
+            type: "set",
+            to: roomCfg.roomId
+        }        
+        var queryN = new dojox.string.Builder(dojox.xmpp.util.createElement("query",{xmlns:dojox.xmpp.muc.MUC_OWNER_NS},false));
+        var req = new dojox.string.Builder(dojox.xmpp.util.createElement("iq",props,false));
+        //queryN.append((new XMLSerializer()).serializeToString(xNode));
+		queryN.append(dojox.xml.parser.innerXML(xNode));
+        queryN.append("</query>");
+        req.append(queryN);
+        req.append("</iq>");
+        var def = this.xmppSession.dispatchPacket(req,"iq",props.id);
+        // reset the map
+        this.cfgVals = [];		
+        def.addCallback(this, function(resp){
+            if(resp.getAttribute('type') == 'result'){
+                //roomCfg.responseCode = dojox.xmpp.muc.CUSTOM_ERR_CODES.SUCCESS;
+				deferred.callback(roomCfg);
+            }else {
+                //roomCfg.responseCode = dojox.xmpp.muc.CUSTOM_ERR_CODES.ROOM_CREATION_FAILED;
+				deferred.errback(dojox.xmpp.muc.CUSTOM_ERR_CODES.ROOM_CREATION_FAILED);
+            }
+            //this.mgr.onCreateRoom(roomCfg);
+        });
+		return deferred;
+    },
+
+    _setValueIntoCfgForm: function(/* namespaceId */nsId, /* value to set */val){
+        if(val === false) val = "0";
+        if(val === true) val = "1";
+        if(!val) return;
+        this.cfgVals[nsId] = val;
+    },
+
+    _setValueIntoCfgForm1: function(/* The config form */xNode){
+        
+        var node, val;
+        //var xNode = dojo.query("x[xmlns='jabber:x:data']", msg)[0];
+        for(var i=0;i<xNode.childNodes.length;i++){
+            node = xNode.childNodes[i];
+            var attr = node.getAttribute('var');
+            val = this.cfgVals[attr];
+            if(val){
+                var valNode = node.getElementsByTagName('value')[0];
+                if(!valNode){
+                    valNode = document.createElement("value");
+                }else {
+                    if(valNode.childNodes[0]) valNode.removeChild(valNode.childNodes[0]);
+                }
+                valNode.appendChild(document.createTextNode(val));
+            }
+        }
+    },
+
+	_doDisconnects: function(connects){
+		dojo.forEach(connects, function(c){
+			if(c) dojo.disconnect(c);
+		});
+	},
+
+    last: ""    
+});
\ No newline at end of file
Index: dojo-release-1.3.2-src/dojox/xmpp/tests/test_xmppService.html
===================================================================
--- dojo-release-1.3.2-src.orig/dojox/xmpp/tests/test_xmppService.html	2010-01-04 11:09:30.000000000 +0530
+++ dojo-release-1.3.2-src/dojox/xmpp/tests/test_xmppService.html	2010-01-04 11:09:32.000000000 +0530
@@ -1,516 +1,809 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
 <html>
-	<head>
-		<style type="text/css">
-			@import "../../../dojo/resources/dojo.css";
-			@import "../../../dijit/themes/dijit.css";
-			@import "../../../dijit/themes/tundra/tundra.css";
-	
-			html,body {
-				width: 100%;
-				height: 100%;
-				overflow: none;
-			}
-			
-			.dijitSplitPane{
-				margin: 5px;
-			}
-
-			#buddyList {
-				cursor:pointer;
-			}
-			
-			.presence {
-				background:#525252;
-				height: 10px;
-				width: 10px;
-				margin:5px;
-			}
-			
-			.online, 
-			.available {
-				background: #00AC00;
-			}
-			
-			
-			.away {
-				background: #E20000;
-			}
-			
-		
-			.offline {
-				background: #ccc;
-			}	
-
-		</style>
-		<title>xmpp test page</title>
-
-		<script type="text/javascript" 
-			src="../../../dojo/dojo.js" djConfig="isDebug:true,parseOnLoad:true">
-		</script>
-		<script type="text/javascript">
-			
-			dojo.require('dijit.layout.LayoutContainer');
-			dojo.require('dijit.layout.ContentPane');
-			dojo.require("dijit.layout.TabContainer");
-			dojo.require("dijit.form.FilteringSelect");
-			dojo.require("dijit.Menu");
-			dojo.require("dijit.Dialog");
-			dojo.require("dijit.Toolbar");
-			dojo.require("dijit.TitlePane");
-			dojo.require("dojox.xmpp.xmppSession");
-
-			dojo.require("dojox.xmpp.widget.ChatSession");
-			
-			dojo.require("dojo.date");
-			dojo.require("dojo.date.locale");
-			dojo.require("dojo.parser");
-		</script>
-
-		<script type="text/javascript">
-		
-			
-			//We want to know which chat instance is selected, so we can associate
-			//the <input> area with it
-			var selectedTab = "";
-			var chatTabs = {};
-			var chatTabContainer = null;
-			var chatInstances = {};
-			
-			/*Local copy of the user's roster*/
-			var roster = {}; 
-			var groups = {};
-			var rosterPresence = {};
-			var selectedJID = null;
-
-			dojo.addOnLoad(function() {
-			
-						dijit.byId("loginDialog").show();
-					var buddyList = dojo.byId("buddyList");
-						dojo.connect(buddyList, "ondblclick",function(evt){
-									var target = findTargetContact(evt);
-									if(target) {
-										openChat(target.jid);
-									}
-						});
-						
-						
-						dojo.connect(buddyList, "oncontextmenu",function(evt){
-								selectedJID = null;
-								var target = findTargetContact(evt);
-								if(target) {
-											selectedJID = target.jid;
-											dojo.stopEvent(evt);
-										var pop = dijit.popup.open({
-											popup: dijit.byId("buddyMenu"),
-											around: target.target,
-											onExecute: function(){
-													dijit.popup.close( dijit.byId("buddyMenu"));
-											},
-											onCancel: function(){
-													dijit.popup.close( dijit.byId("buddyMenu"));
-											}
-										});
-									
-								}
-						});
-						
-					
-						
-			});
-			
-		   	function findTargetContact(evt) {
-				var buddyList = dojo.byId("buddyList");
-					var jid = null;
-					var target = evt.target;
-					while(!jid && target != buddyList) {
-						jid = target.getAttribute("imContactId");
-						if(!jid) {
-							target = target.parentNode;
-						}
-					}
-					return jid ? {jid:jid, target:target} : null;
-			}
-
-			function login() {
-				
-					var bindUrl = dijit.byId("bindUrl").getValue();
-					var domain = dijit.byId("loginDomain").getValue();
-					var jid = dijit.byId("loginJid").getValue();
-					var password = dijit.byId("loginPassword").getValue();
-				
-					var useScriptSrcTransport = false;
-					if(bindUrl.indexOf("http") == 0) {
-						useScriptSrcTransport = true;
-					}
-					var options =  {
-							serviceUrl:bindUrl,// "http://other.host.local/http-bind/",
-							hold: 1,
-							secure: false,
-							useScriptSrcTransport: useScriptSrcTransport,
-							wait: 60,
-							lang: 'en',
-							retryCount: 2,
-							domain: domain
-						};
-
-					session = new dojox.xmpp.xmppSession(options);
-					//TESTUSER
-					
-					//currently svc.openSession doesn't accept any params
-					//so the iwc.userPrefs stuff above setup the user id, dont' forget it!		
-					session.open(jid, password, "test-client");
-
-
-
-					buddyList = dojo.byId("buddyList");
-					chatTabContainer = dijit.byId("chatTabs");
-					//sendInput = dojo.byId("sendInput");
-
-					//When the session becomes active, get the buddy list and populate it
-					dojo.connect(session, "onActive", function(){
-						session.presenceService.publish({});
+    <head>
+        <style type="text/css">
+            @import "../../../dojo/resources/dojo.css";
+            @import "../../../dijit/themes/dijit.css";
+            @import "../../../dijit/themes/tundra/tundra.css";
+
+            html,body {
+                width: 100%;
+                height: 100%;
+                overflow: none;
+            }
+
+            .dijitSplitPane{
+                margin: 5px;
+            }
+
+            #buddyList {
+                cursor:pointer;
+            }
+
+            .presence {
+                background:#525252;
+                height: 10px;
+                width: 10px;
+                margin:5px;
+            }
+
+            .online,
+            .available {
+                background: #00AC00;
+            }
+
+
+            .away {
+                background: #E20000;
+            }
+
+
+            .offline {
+                background: #ccc;
+            }
+
+            .hide {
+                display: none;
+            }
+
+        </style>
+        <title>xmpp test page</title>
+
+        <script type="text/javascript"
+            src="../../../dojo/dojo.js" djConfig="isDebug:true,parseOnLoad:true">
+        </script>
+        <script type="text/javascript">
+
+            dojo.require('dijit.layout.LayoutContainer');
+            dojo.require('dijit.layout.BorderContainer');
+            dojo.require('dijit.layout.ContentPane');
+            dojo.require("dijit.layout.TabContainer");
+            dojo.require("dijit.form.FilteringSelect");
+            dojo.require("dijit.Menu");
+			dojo.require("dijit.MenuItem");
+            dojo.require("dijit.Dialog");
+            dojo.require("dijit.Toolbar");
+            dojo.require("dijit.TitlePane");
+            dojo.require("dijit.form.ComboBox");
+			dojo.require('dijit.form.DropDownButton');
+
+            dojo.require("dojox.xmpp.xmppSession");
+
+            dojo.require("dojox.xmpp.widget.ChatSession");
+            dojo.require("dojox.xmpp.widget.MUCSession");
+
+            dojo.require("dojo.data.ItemFileWriteStore");
+            dojo.require("dojo.date");
+            dojo.require("dojo.date.locale");
+            dojo.require("dojo.parser");
+        </script>
+
+        <script type="text/javascript">
+
+
+            //We want to know which chat instance is selected, so we can associate
+            //the <input> area with it
+            var selectedTab = "";
+            var chatTabs = {};
+            var chatTabContainer = null;
+            var chatInstances = {};
+
+            /*Local copy of the user's roster*/
+            var roster = {};
+            var groups = {};
+            var rosterPresence = {};
+            var selectedJID = null;
+
+            dojo.addOnLoad(function() {
+                        dijit.byId("loginDialog").show();
+                    var buddyList = dojo.byId("buddyList");
+                        dojo.connect(buddyList, "ondblclick",function(evt){
+                                    var target = findTargetContact(evt);
+                                    if(target) {
+                                        openChat(target.jid);
+                                    }
+                        });
+
+
+                        dojo.connect(buddyList, "oncontextmenu",function(evt){
+                                selectedJID = null;
+                                var target = findTargetContact(evt);
+                                if(target) {
+                                            selectedJID = target.jid;
+                                            dojo.stopEvent(evt);
+                                        var pop = dijit.popup.open({
+                                            popup: dijit.byId("buddyMenu"),
+                                            around: target.target,
+                                            onExecute: function(){
+                                                    dijit.popup.close( dijit.byId("buddyMenu"));
+                                            },
+                                            onCancel: function(){
+                                                    dijit.popup.close( dijit.byId("buddyMenu"));
+                                            }
+                                        });
+
+                                }
+                        });
+
+                        dojo.connect(dijit.byId("confTab"),"onShow", function(){
+                            if(!mucManager) dijit.byId("confDialog").show();
+                                else dijit.byId("confDialog").hide();
+                        });
+
+
+            });
+
+               function findTargetContact(evt) {
+                var buddyList = dojo.byId("buddyList");
+                    var jid = null;
+                    var target = evt.target;
+                    while(!jid && target != buddyList) {
+                        jid = target.getAttribute("imContactId");
+                        if(!jid) {
+                            target = target.parentNode;
+                        }
+                    }
+                    return jid ? {jid:jid, target:target} : null;
+            }
+
+            function login() {
+
+                    var bindUrl = dijit.byId("bindUrl").getValue();
+                    var domain = dijit.byId("loginDomain").getValue();
+                    var jid = dijit.byId("loginJid").getValue();
+                    var password = dijit.byId("loginPassword").getValue();
+					nick = jid;
+
+                    var useScriptSrcTransport = false;
+                    if(bindUrl.indexOf("http") == 0) {
+                        useScriptSrcTransport = true;
+                    }
+                    var options =  {
+                            serviceUrl:bindUrl,// "http://other.host.local/http-bind/",
+                            hold: 1,
+                            secure: false,
+                            useScriptSrcTransport: useScriptSrcTransport,
+                            wait: 60,
+                            lang: 'en',
+                            retryCount: 2,
+                            domain: domain
+                        };
+
+                    session = new dojox.xmpp.xmppSession(options);
+                    //TESTUSER
+
+                    //currently svc.openSession doesn't accept any params
+                    //so the iwc.userPrefs stuff above setup the user id, dont' forget it!
+                    session.open(jid, password, "test-client");
+
+
+
+                    buddyList = dojo.byId("buddyList");
+                    chatTabContainer = dijit.byId("chatTabs");
+                    //sendInput = dojo.byId("sendInput");
+
+                    //When the session becomes active, get the buddy list and populate it
+                    dojo.connect(session, "onActive", function(){
+                        session.presenceService.publish({});
+                    });
+
+                    dojo.connect(this.session, 'onRosterAdded',  buddyAdded);
+
+                    dojo.connect(this.session, 'onRosterChanged',  function(rosterItem, previousCopy) {
+                        var presence = rosterPresence[rosterItem.id];
+                        buddyRemoved(previousCopy);
+                        buddyAdded(rosterItem);
+                        if(presence) {
+                            updateBuddyPresence(presence);
+                        }
+                    });
+                    dojo.connect(this.session, 'onRosterRemoved',  buddyRemoved);
+
+
+                    dojo.connect(session, "onRosterUpdated", function() {
+                            for(var i=0;i<session.roster.length;i++){
+                                var buddy = session.roster[i];
+                                roster[buddy.jid] = buddy;
+                                if(buddy.groups.length == 0 ) {
+                                    addBuddyToGroup(buddy, "buddies");
+                                } else {
+                                    for(var j= 0; j < buddy.groups.length; j++) {
+                                        addBuddyToGroup(buddy, buddy.groups[j]);
+                                    }
+                                }
+                            }
+                            for(groupName in groups) {
+                                createGroup(groupName);
+                            }
+                    });
+
+
+
+                    //subscribe to presence notifications
+                    dojo.connect(session, 'onPresenceUpdate', updateBuddyPresence);
+
+
+                    //subscribe to onSubscriptionRequest.  For this test, we'll just
+                    //automatically accept any susbscription request
+                    dojo.connect(session, "onSubscriptionRequest", function(from){
+                        session.presenceService.approveSubscription(from);
+                    });
+
+
+
+                    dojo.connect(session, "onRegisterChatInstance", function(instance, message){
+
+                        //in the case of we are creating a new chat instance, defer the tab creation
+                        //until the invite has occurred and the contact's uid has been added
+                        if (instance.uid){
+                            if(!chatInstances[instance.uid] || chatInstances[instance.uid].chatid != instance.chatid){
+                                newMessage(instance, instance.uid, message);
+                            }
+                            chatInstances[instance.uid] = instance;
+                        }
+
+                        dojo.connect(instance, "onInvite", dojo.hitch(this,function(contact){
+                            chatInstances[contact] = instance;
+                            newMessage(instance, contact, null);
+                        }));
+
+
+                        //do something when we get a new message from this chat instance
+                        dojo.connect(instance, "onNewMessage", dojo.hitch(this, function(msg){
+                            newMessage(instance, instance.uid, msg);
+                        }));
+
+                        //I'm not going to wire this up for this example, but this
+                        //is the event that would signal whether a person is writing,
+                        //idle, etc (ie, the little pencil in adium)
+                        dojo.connect(instance, "setState", function(state){
+                            console.log("IM: ",  instance.uid, " is now ", state);
+                        });
+                    });
+
+                    dojo.connect(session, "onMUCServiceReady", this, "onMUCServiceReady");
+
+            }
+
+            function createGroup(groupName) {
+                var div = document.createElement("div");
+                buddyList.appendChild(div);
+                var groupItems = groups[groupName].items;
+                 var buffer = new dojox.string.Builder();
+                for(var i=0;i<groupItems.length;i++){
+                    var buddy = groupItems[i];
+                    renderBuddy(buffer, buddy);
+                }
+                div.innerHTML = buffer.toString();
+                var titlePane = new dijit.TitlePane({title: groupName}, div);
+
+                 groups[groupName].container = titlePane;
+                return titlePane;
+            }
+
+            function updateBuddyPresence(p){
+                rosterPresence[p.from] = p;
+                dojo.query('div[imContactId="'+p.from+'"]', buddyList).forEach(function(contact) {
+                    contact.firstChild.className = "dijitInline presence "  + p.show;
+                 });
+
+            }
+
+            function buddyRemoved(buddy){
+                delete roster[buddy.id];
+                delete rosterPresence[buddy.id];
+                dojo.query('div[imContactId="'+buddy.id+'"]', buddyList).forEach(function(contact) {
+                        contact.parentNode.removeChild(contact);
+                 });
+            }
+
+            function buddyAdded(buddy) {
+                    roster[buddy.id] =buddy
+                    if(buddy) {
+                        var div  = null;
+                        if(buddy.groups.length == 0 ) {
+                            addBuddyToGroup(buddy, "buddies");
+                            var container = groups["buddies"].container;
+                            if(container) {
+                                div = container.containerNode;
+                                var buffer = new dojox.string.Builder();
+                                buffer.append(div.innerHTML);
+                                renderBuddy(buffer, buddy);
+                                div.innerHTML = buffer;
+                            } else {
+                                div =  createGroup("buddies").containerNode;
+                            }
+
+                        } else {
+                            for(var j= 0; j < buddy.groups.length; j++) {
+                                var groupName = buddy.groups[j];
+                                addBuddyToGroup(buddy, groupName);
+                                var container = groups[groupName].container;
+                                if(container) {
+                                    div = container.containerNode;
+                                    var buffer = new dojox.string.Builder();
+                                    buffer.append(div.innerHTML);
+                                    renderBuddy(buffer, buddy);
+                                    div.innerHTML = buffer;
+                                } else {
+                                    div =  createGroup(groupName).containerNode;
+                                }
+
+                            }
+                        }
+                    }
+
+            }
+
+
+            function renderBuddy(buffer, buddy) {
+                buffer.append('<div imContactId="');
+                buffer.append(buddy.jid);
+                buffer.append('"><div class="dijitInline presence"></div><div class="dijitInline ">');
+                buffer.append(buddy.name?buddy.name:buddy.jid);
+                buffer.append('</div></div>');
+            }
+
+            function addBuddyToGroup(buddy, groupName) {
+                var group = groups[groupName];
+                if(!group) {
+                    group = {name:groupName, items: []};
+                    groups[groupName] =group;
+                }
+                group.items.push(buddy);
+            }
+
+            function newMessage(instance, jid, message) {
+                var tab = chatTabs[jid];
+                if(!tab) {
+                    var div = document.createElement("div");
+                    var buddy = roster[jid];
+                    var chatWith = jid;
+                    if(buddy && buddy.name) {
+                        chatWith = buddy.name;
+                    }
+                     tab = new dojox.xmpp.widget.ChatSession({title: jid, chatWith: chatWith, instance: instance, closable: true}, div);
+                    dojo.connect(tab, "onClose", function() {
+                        delete chatTabs[jid];
+                    });
+                    chatTabContainer.addChild(tab);
+                    chatTabContainer.selectChild(tab);
+                    chatTabContainer.layout();
+                    chatTabs[jid] = tab;
+                }
+                tab.displayMessage(message);
+
+            }
+
+            function openChat(jid){
+                var tab = chatTabs[jid];
+                if(tab) {
+                  chatTabContainer.selectChild(tab);
+                }
+
+                var chatInstance = new dojox.xmpp.ChatService();
+                session.registerChatInstance(chatInstance);
+                chatInstance.invite(jid);
+            }
+
+
+            function updatePresence(p){
+                //since the filtering select wants to call its onChange
+                //at startup and the svc isn't started up yet, we just ignore it
+                //for this test case
+                if (session && session.presenceService) {
+                    session.presenceService.publish({show:p});
+                }
+            }
+
+
+            function addUser() {
+                var userJID = dijit.byId("userJID").getValue();
+                var userAlias = dijit.byId("userAlias").getValue();
+                var userGroups = dijit.byId("userGroups").getValue();
+
+                var groups = userGroups.split(",");
+
+                session.rosterService.addRosterItem(userJID, userAlias, groups);
+            }
+
+            function showAddBuddy() {
+                dijit.byId("userJID").setValue("");
+                dijit.byId("userJID").setDisabled(false);
+
+                dijit.byId("userAlias").setValue("");
+                dijit.byId("userGroups").setValue("");
+                dijit.byId('addUser').show();
+            }
+
+            function showEditBuddy() {
+                var buddy = roster[selectedJID];
+                if(buddy) {
+                    dijit.byId("userJID").setValue(selectedJID);
+                    dijit.byId("userJID").setDisabled(true);
+
+                    dijit.byId("userAlias").setValue(buddy.name? buddy.name : "");
+                    dijit.byId("userGroups").setValue(buddy.groups? buddy.groups.join(",") : "");
+                    dijit.byId('addUser').show();
+                }
+            }
+
+            function subscribeBuddy(){
+                session.presenceService.subscribe(selectedJID);
+            }
+
+
+            function deleteBuddy(){
+                if(confirm("Sure you want to delete "  + selectedJID + " ?")) {
+                    session.rosterService.removeRosterItem(selectedJID);
+                }
+            }
+
+            //MUC Tests - Start
+            var mucManager;
+            var mucTabContainer = null;
+            var mucTabArr = [];
+            var mucSessionsArr = [];
+            var options = new dojo.data.ItemFileWriteStore({data: {identifier: 'name', items:[]}});
+            var nick = "confuser";
+
+
+            function onMUCServiceReady(mucMgr) {
+                mucManager = mucMgr;
+				var def = mucManager.retrieveBookmarks();
+				def.addCallback(function(rooms){
+					dojo.forEach(rooms, function(room){
+						console.log("Bookmarked Room-> jid="+room.jid+", name= "+room.name);
+						options.newItem({name: room.jid});
 					});
-					
-					dojo.connect(this.session, 'onRosterAdded',  buddyAdded);
-					
-					dojo.connect(this.session, 'onRosterChanged',  function(rosterItem, previousCopy) { 
-						var presence = rosterPresence[rosterItem.id];
-						buddyRemoved(previousCopy);
-						buddyAdded(rosterItem);
-						if(presence) {
-							updateBuddyPresence(presence);
-						}	
-					});
-					dojo.connect(this.session, 'onRosterRemoved',  buddyRemoved);
-				
-
-					dojo.connect(session, "onRosterUpdated", function() {
-							for(var i=0;i<session.roster.length;i++){
-								var buddy = session.roster[i];
-								roster[buddy.jid] = buddy;
-								if(buddy.groups.length == 0 ) {
-									addBuddyToGroup(buddy, "buddies");
-								} else {
-									for(var j= 0; j < buddy.groups.length; j++) {
-										addBuddyToGroup(buddy, buddy.groups[j]);
-									}
-								}	
-							}
-							for(groupName in groups) {
-								createGroup(groupName);
-							}
-					});
-					
-					
-
-					//subscribe to presence notifications
-					dojo.connect(session, 'onPresenceUpdate', updateBuddyPresence);
-
-
-					//subscribe to onSubscriptionRequest.  For this test, we'll just
-					//automatically accept any susbscription request
-					dojo.connect(session, "onSubscriptionRequest", function(from){
-						session.presenceService.approveSubscription(from);
-					});
-
-
-
-					dojo.connect(session, "onRegisterChatInstance", function(instance, message){
-
-						//in the case of we are creating a new chat instance, defer the tab creation
-						//until the invite has occurred and the contact's uid has been added
-						if (instance.uid){
-							if(!chatInstances[instance.uid] || chatInstances[instance.uid].chatid != instance.chatid){
-								newMessage(instance, instance.uid, message);
-							}
-							chatInstances[instance.uid] = instance;		
-						}
-
-						dojo.connect(instance, "onInvite", dojo.hitch(this,function(contact){
-							chatInstances[contact] = instance;
-							newMessage(instance, contact, null);
-						}));	
-
-
-						//do something when we get a new message from this chat instance
-						dojo.connect(instance, "onNewMessage", dojo.hitch(this, function(msg){
-							newMessage(instance, instance.uid, msg);		
-						}));		
-
-						//I'm not going to wire this up for this example, but this
-						//is the event that would signal whether a person is writing,
-						//idle, etc (ie, the little pencil in adium)
-						dojo.connect(instance, "setState", function(state){
-							console.log("IM: ",  instance.uid, " is now ", state);
-						});
+				});
+                dojo.connect(mucManager, "onInvitation",function(invite){
+                    if(confirm(invite.from+ "has invited you to join "+invite.room+".\nReason:"+invite.reason)){
+                        joinMUC(invite.room);
+                    }else {
+						invite.reason = "";
+						mucManager.declineInvitation(invite);
+					}
+                });
+                dojo.connect(mucManager, "onCreateRoom", function(roomCfg, mucService){
+                    if(roomCfg.responseCode == '200'){
+                        console.log("Room creation was successful");
+                        joinMUC(roomCfg.roomId, mucService);
+                        options.newItem({name: roomCfg.roomId});
+                    }else if(roomCfg.responseCode == '402'){
+                        console.log("Room creation failed because room is already present");
+                    }else {
+                        console.log("Room creation failed");
+                    }
+                });
+                dojo.connect(this.mucManager, "onRegisterChatInstance",function(instance){
+                    var tab = mucTabArr[instance.uid]
+                    dojo.connect(instance,"onInitRoster", function(roster){
+						console.log("Is owner= "+instance.isOwner());
+						console.log("Has voice= "+instance.hasVoice());
+                        tab.createRoster(roster);
+                    });
+                    dojo.connect(instance,"onUpdateRoster", function(nick, occupant){
+						console.log("test_xmppService::onUpdateRoster: Roster updated for nick "+nick, "Occupant= ", occupant);
+                        tab.updateRoster(nick, occupant);
+                    });
+                    dojo.connect(instance, "onNewMessage", function(message){
+                        tab.displayMessage(message);
+                    });
+					dojo.connect(instance, "onInvitationDeclined",function(invite){
+						alert(invite.from+ "has declined your invitation to join "+invite.room+".\nReason:"+invite.reason);
 					});
-
-			}
-			
-			function createGroup(groupName) {
-				var div = document.createElement("div");
-				buddyList.appendChild(div);
-				var groupItems = groups[groupName].items;
-				 var buffer = new dojox.string.Builder();
-				for(var i=0;i<groupItems.length;i++){
-					var buddy = groupItems[i];
-					renderBuddy(buffer, buddy);
-				}
-				div.innerHTML = buffer.toString();
-				var titlePane = new dijit.TitlePane({title: groupName}, div);
-				
-				 groups[groupName].container = titlePane;
-				return titlePane;
-			}
-			
-			function updateBuddyPresence(p){
-				rosterPresence[p.from] = p;
-				dojo.query('div[imContactId="'+p.from+'"]', buddyList).forEach(function(contact) { 
-					contact.firstChild.className = "dijitInline presence "  + p.show;
-				 });
-			
-			}
-			
-			function buddyRemoved(buddy){
-				delete roster[buddy.id];
-				delete rosterPresence[buddy.id];
-				dojo.query('div[imContactId="'+buddy.id+'"]', buddyList).forEach(function(contact) { 
-						contact.parentNode.removeChild(contact);
-				 });
-			}
-			
-			function buddyAdded(buddy) {
-					roster[buddy.id] =buddy
-					if(buddy) {
-						var div  = null;
-						if(buddy.groups.length == 0 ) {
-							addBuddyToGroup(buddy, "buddies");
-							var container = groups["buddies"].container;
-							if(container) {
-								div = container.containerNode;
-								var buffer = new dojox.string.Builder();
-								buffer.append(div.innerHTML);
-								renderBuddy(buffer, buddy);
-								div.innerHTML = buffer;
-							} else {
-								div =  createGroup("buddies").containerNode;
-							}
-						
-						} else {
-							for(var j= 0; j < buddy.groups.length; j++) {
-								var groupName = buddy.groups[j];
-								addBuddyToGroup(buddy, groupName);
-								var container = groups[groupName].container;
-								if(container) {
-									div = container.containerNode;
-									var buffer = new dojox.string.Builder();
-									buffer.append(div.innerHTML);
-									renderBuddy(buffer, buddy);
-									div.innerHTML = buffer;
-								} else {
-									div =  createGroup(groupName).containerNode;
-								}
-								
-							}
-						}
+                    instance.joinRoom();
+                });
+            }
+
+            function _newConferenceTab(room, mucService){
+                var div = document.createElement("div");
+                if(!mucService){
+                    mucService = new dojox.xmpp.MUCService(room, nick);
+                }
+                var tab = new dojox.xmpp.widget.MUCSession({title: room, room: room, session:session, nick:nick, mucManager: mucManager, instance:mucService,liveSplitters:true, closable: true}, div);
+                dojo.connect(tab,"onClose",function(){
+                    leaveRoom(room);
+                });
+                mucTabArr[room] = tab;
+                mucTabContainer = dijit.byId("mucTabs");
+                mucTabContainer.addChild(tab);
+                mucTabContainer.selectChild(tab);
+                mucTabContainer.layout();
+                session.registerMUCInstance(mucService);
+                mucService.setSession(session);
+                return tab;
+            }
+
+            function joinMUC(room, mucService) {
+                //var room = document.getElementById('confSel').value;
+                if(room.search("@") < 0){
+                    room = room+"@"+mucManager.mucService;
+                }
+                var roomTab = mucTabArr[room];
+                if(roomTab == null){
+                    roomTab = _newConferenceTab(room, mucService);
+                }
+                mucTabContainer = dijit.byId("mucTabs");
+                mucTabContainer.selectChild(roomTab);
+                mucTabContainer.layout();
+            }
+
+            function leaveRoom(room, close) {
+                if(room.search("@") < 0){
+                    room = room+"@"+mucManager.mucService;
+                }
+                mucManager.leaveRoom(room);
+                var roomTab = mucTabArr[room];
+                if(!roomTab) return;
+                //roomTab.disconnectAll();
+                mucTabArr[room] = null;
+                if(close){
+                    mucTabContainer.closeChild(roomTab);
+                }
+            }
+
+            function inviteToMUC(room) {
+                if(room.search("@") < 0){
+                    room = room+"@"+mucManager.mucService;
+                }
+                var mucInst = mucManager.getMUCInstance(room);				
+                var useridStr = prompt("Enter userid:");
+                if(!useridStr) return;
+				var userids = useridStr.split(",");
+				for(var i=0; i<userids.length;i++){
+					var userid = userids[i];
+					if(userid.search("@") < 0){
+						userid = userid+"@"+session.session.domain;
+						userids[i] = userid;
 					}
-					
-			}
-			
-			
-			function renderBuddy(buffer, buddy) {
-				buffer.append('<div imContactId="');
-				buffer.append(buddy.jid);
-				buffer.append('"><div class="dijitInline presence"></div><div class="dijitInline ">');
-				buffer.append(buddy.name?buddy.name:buddy.jid);
-				buffer.append('</div></div>');
-			}
-			
-			function addBuddyToGroup(buddy, groupName) {
-				var group = groups[groupName];
-				if(!group) {
-					group = {name:groupName, items: []};
-					groups[groupName] =group;
 				}
-				group.items.push(buddy);
-			}
+                mucInst.invite(userids, "Join My Conference");
+            }
 
-			function newMessage(instance, jid, message) {
-				var tab = chatTabs[jid];
-				if(!tab) {
-					var div = document.createElement("div");
-					var buddy = roster[jid];
-					var chatWith = jid;
-					if(buddy && buddy.name) {
-						chatWith = buddy.name;
-					}
-				 	tab = new dojox.xmpp.widget.ChatSession({title: jid, chatWith: chatWith, instance: instance, closable: true}, div);
-					dojo.connect(tab, "onClose", function() {
-						delete chatTabs[jid];
+            function destroyRoom(room) {
+                if(room.search("@") < 0){
+                    room = room+"@"+mucManager.mucService;
+                }
+                if(confirm("Sure you want to delete this room?")){
+                    var def = mucManager.destroyRoom(room);
+					def.addCallback(function(){
+						console.log("Room destroyed successfully");
+                        leaveRoom(room, true);
+                        options.fetch({query: {name:room}, onComplete: function(items){
+                            for (var i = 0; i < items.length; i++){
+                                options.deleteItem(items[i]);
+                            }
+                            options.save();
+                        }});
+					}).addErrback(function(){
+						console.log("Room destroy failed");
 					});
-					chatTabContainer.addChild(tab);
-					chatTabContainer.selectChild(tab);	
-					chatTabContainer.layout();
-					chatTabs[jid] = tab;
-				}
-				tab.displayMessage(message);
-				
-			}
+                }
+            }
 
-			function openChat(jid){
-				var tab = chatTabs[jid];
-				if(tab) {
-				  chatTabContainer.selectChild(tab);	
-				}
-
-				var chatInstance = new dojox.xmpp.ChatService();
-				session.registerChatInstance(chatInstance);
-				chatInstance.invite(jid);
-			}
-
-
-			function updatePresence(p){
-				//since the filtering select wants to call its onChange
-				//at startup and the svc isn't started up yet, we just ignore it 
-				//for this test case
-				if (session && session.presenceService) {
-					session.presenceService.publish({show:p});
-				}
-			}
-			
-			
-			function addUser() {
-			    var userJID = dijit.byId("userJID").getValue();
-				var userAlias = dijit.byId("userAlias").getValue();
-				var userGroups = dijit.byId("userGroups").getValue();
-				
-				var groups = userGroups.split(",");
-				
-				session.rosterService.addRosterItem(userJID, userAlias, groups);
-			}
-			
-			function showAddBuddy() {
-				dijit.byId("userJID").setValue("");
-				dijit.byId("userJID").setDisabled(false);
-				
-				dijit.byId("userAlias").setValue("");
-				dijit.byId("userGroups").setValue("");
-				dijit.byId('addUser').show();
-			}
-			
-			function showEditBuddy() {
-				var buddy = roster[selectedJID];
-				if(buddy) { 
-					dijit.byId("userJID").setValue(selectedJID);
-					dijit.byId("userJID").setDisabled(true);
-
-					dijit.byId("userAlias").setValue(buddy.name? buddy.name : "");
-					dijit.byId("userGroups").setValue(buddy.groups? buddy.groups.join(",") : "");
-					dijit.byId('addUser').show();
+            function createInstantRoom() {
+                var deferred = mucManager.getUniqueName();
+                deferred.addCallback(function(roomId){
+                    var roomCfg = new dojox.xmpp.MUCRoomConfig();
+                    roomCfg.roomId = roomId+'@'+mucManager.mucService;
+                    var def = mucManager.createInstantRoom(nick, roomCfg);
+					def.addCallback(this, function(resp){
+						console.log("Instant room creation was successful");
+						joinMUC(resp.roomCfg.roomId, resp.mucService);
+						options.newItem({name: roomCfg.roomId});
+					}).addErrback(function(errCode){
+						if(errCode == '402'){
+							console.log("Instant room creation failed because room is already present");
+						}else {
+							console.log("Instant room creation failed");
+						}
+					});
+                }).addErrback(function(){
+					console.error("Failed to retrieve unique name from server");
+					// fall-back goes here, the caller could generate a random string
+					// and create a room
+				});
+            }
+
+			function createReservedRoom() {
+				var roomId = prompt("Enter Room Name:");
+				if(roomId.search("@") < 0){
+                    roomId = roomId+"@"+mucManager.mucService;
+                }
+				var roomCfg = new dojox.xmpp.MUCRoomConfig();
+				roomCfg.roomId = roomId;
+				var def = mucManager.createRoom(nick, roomCfg);
+				def.addCallback(this, function(resp){
+					console.log("Room creation was successful");
+					joinMUC(resp.roomCfg.roomId, resp.mucService);
+                    options.newItem({name: roomCfg.roomId});
+				}).addErrback(function(errCode){
+					if(errCode == '402'){
+                        console.log("Room creation failed because room is already present");
+                    }else {
+                        console.log("Room creation failed");
+                    }
+				});
+
+            }
+
+            function execConfAction(action) {
+                if(!isMUCEnabled()) return;
+                var room = document.getElementById('confSel').value
+				if(action == 'Select Action'){
+					return;
 				}
-			}
-			
-			function subscribeBuddy(){
-				session.presenceService.subscribe(selectedJID);
-			}
-			
-			
-			function deleteBuddy(){
-				if(confirm("Sure you want to delete "  + selectedJID + " ?")) {
-					session.rosterService.removeRosterItem(selectedJID);
+				if(room == 'Select Room'){
+					alert("Select a room or create a new one");
+					return;
 				}
-			}
-
-		</script>
-	</head>
-
-	<body class="tundra">
-		
-		<div dojoType="dijit.Dialog" id="loginDialog" style="display: none; width:400px" title="Login">
-			<table>
-				<tr>
-					<td><label for="name">JID: </label></td>
-					<td><input dojoType="dijit.form.TextBox" type="text"  id="loginJid" value=""></td>
-				</tr>
-				<tr>
-					<td><label for="loc">Password: </label></td>
-					<td><input dojoType="dijit.form.TextBox" type="password"  id="loginPassword" value=""></td>
-				</tr>
-				<tr>
-					<td><label for="loc">Domain: </label></td>
-					<td><input dojoType="dijit.form.TextBox" type="text"  id="loginDomain" value=""></td>
-				</tr>
-				<tr>
-					<td><label for="loc">HTTP-Bind URL: </label></td>
-					<td><input dojoType="dijit.form.TextBox" type="text"  id="bindUrl" value="/http-bind/"></td>
-				</tr>
-				<tr>
-					<td colspan="2"><small>Note: a relative Bind URL will use the standard XHR transport and a full URL will use the cross-domain BOSH script syntax.</small></td>
-				</tr>
-				<tr>
-					<td colspan="2" align="center">
-						<button dojoType="dijit.form.Button" onClick="login()" type="submit">Login</button></td>
-				</tr>
-			</table>
-		</div>
-		
-		<div dojoType="dijit.Dialog" id="addUser" style="display: none" title="Add User">
-			<table>
-				<tr>
-					<td><label for="name">JID: </label></td>
-					<td><input dojoType="dijit.form.TextBox" type="text"  id="userJID" value=""></td>
-				</tr>
-				<tr>
-					<td><label for="name">Alias: </label></td>
-					<td><input dojoType="dijit.form.TextBox" type="text"  id="userAlias" value=""></td>
-				</tr>
-				<tr>
-					<td><label for="name">Groups: </label></td>
-					<td><input dojoType="dijit.form.TextBox" type="text"  id="userGroups" value=""></td>
-				</tr>
-				<tr>
-					<td colspan="2" align="center">
-						<button dojoType="dijit.form.Button"  onClick="addUser()" type="submit">Save</button>
-						<button dojoType="dijit.form.Button" onClick="dijit.byId('addUser').hide();" type="submit">Cancel</button></td>
-				</tr>
-			</table>
-		</div>
-			<div dojoType="dijit.Menu" id="buddyMenu" style="display:none; width: 190px;">
-			
-				<div dojoType="dijit.MenuItem"  onClick="showEditBuddy" >
-				 	Edit Buddy
-				</div>
-				<div dojoType="dijit.MenuItem"   onClick="subscribeBuddy">
-					Re-request subscription
-				</div>
-				<div dojoType="dijit.MenuItem"   onClick="deleteBuddy">
-					Delete
-				</div>
-
-			</div>
-		
-		<div dojoType="dijit.layout.LayoutContainer" style="width: 100%; height: 100%;">
-			<div dojoType="dijit.layout.ContentPane" layoutAlign="top" style="height: 50px; background: #999999;">
-				XMPP Test Client
-				<div style="top:10px; float: right;">
-					Status: <select dojoType="dijit.form.FilteringSelect" id="presence" name="presence" autoComplete="false" onChange="updatePresence(arguments[0]);">
-						<option value="available" selected>Online</option>
-						<option value="away">Away</option>
-						<option value="chat">Free to Chat</option>
-						<option value="dnd">Do Not Disturb</option>
-						<option value="xa">Extended Away</option>
-					</select>
-							<button dojoType="dijit.form.Button" id="addUserButton" onClick="showAddBuddy()">Add Buddy</button>
-				</div>
-			</div>
-		
-			<div id="buddyListCP" dojoType="dijit.layout.ContentPane" layoutAlign="right" style="width: 200px; border: 1px solid #999999; overflow:auto;">
-				
-			  	<div id="buddyList">
-				</div>
-			</div>
-			<div id="chatTabs" dojoType="dijit.layout.TabContainer" layoutAlign="client" style="border: 1px solid #999999; height:100%"></div>
-		</div>	
-	</body>
+                if(action == 'Join'){
+                    joinMUC(room);
+                } else if(action == 'Leave'){
+                    leaveRoom(room, true);
+                } else if(action == 'Invite'){
+                    inviteToMUC(room);
+                } else if(action == 'Destroy'){
+                    destroyRoom(room);
+                }
+            }
+
+			function kick(nick, room){
+				var mucInst = mucManager.getMUCInstance(room);
+				var def = mucInst.kick(nick);
+				def.addCallback(function(){
+					console.log("successfully kicked user "+nick);
+				}).errback(function(){
+					console.log("failed to kicked user ");
+				});
+				//this.session.kick(nick);
+			}
+
+            function isMUCEnabled(){
+                if(!mucManager) dijit.byId("confDialog").show();
+                    else dijit.byId("confDialog").hide();
+                return (mucManager != null)
+            }
+
+        </script>
+    </head>
+
+    <body class="tundra">
+
+        <div dojoType="dijit.Dialog" id="loginDialog" style="display: none; width:400px" title="Login">
+            <table>
+                <tr>
+                    <td><label for="name">JID: </label></td>
+                    <td><input dojoType="dijit.form.TextBox" type="text"  id="loginJid" value=""></td>
+                </tr>
+                <tr>
+                    <td><label for="loc">Password: </label></td>
+                    <td><input dojoType="dijit.form.TextBox" type="password"  id="loginPassword" value=""></td>
+                </tr>
+                <tr>
+                    <td><label for="loc">Domain: </label></td>
+                    <td><input dojoType="dijit.form.TextBox" type="text"  id="loginDomain" value=""></td>
+                </tr>
+                <tr>
+                    <td><label for="loc">HTTP-Bind URL: </label></td>
+                    <td><input dojoType="dijit.form.TextBox" type="text"  id="bindUrl" value=""></td>
+                </tr>
+                <tr>
+                    <td colspan="2"><small>Note: a relative Bind URL will use the standard XHR transport and a full URL will use the cross-domain BOSH script syntax.</small></td>
+                </tr>
+                <tr>
+                    <td colspan="2" align="center">
+                        <button dojoType="dijit.form.Button" onClick="login()" type="submit">Login</button></td>
+                </tr>
+            </table>
+        </div>
+
+        <div dojoType="dijit.Dialog" id="addUser" style="display: none" title="Add User">
+            <table>
+                <tr>
+                    <td><label for="name">JID: </label></td>
+                    <td><input dojoType="dijit.form.TextBox" type="text"  id="userJID" value=""></td>
+                </tr>
+                <tr>
+                    <td><label for="name">Alias: </label></td>
+                    <td><input dojoType="dijit.form.TextBox" type="text"  id="userAlias" value=""></td>
+                </tr>
+                <tr>
+                    <td><label for="name">Groups: </label></td>
+                    <td><input dojoType="dijit.form.TextBox" type="text"  id="userGroups" value=""></td>
+                </tr>
+                <tr>
+                    <td colspan="2" align="center">
+                        <button dojoType="dijit.form.Button"  onClick="addUser()" type="submit">Save</button>
+                        <button dojoType="dijit.form.Button" onClick="dijit.byId('addUser').hide();" type="submit">Cancel</button></td>
+                </tr>
+            </table>
+        </div>
+            <div dojoType="dijit.Menu" id="buddyMenu" style="display:none; width: 190px;">
+
+                <div dojoType="dijit.MenuItem"  onClick="showEditBuddy" >
+                     Edit Buddy
+                </div>
+                <div dojoType="dijit.MenuItem"   onClick="subscribeBuddy">
+                    Re-request subscription
+                </div>
+                <div dojoType="dijit.MenuItem"   onClick="deleteBuddy">
+                    Delete
+                </div>
+
+            </div>
+            <div dojoType="dijit.layout.BorderContainer" style="width: 100%; height: 100%;">
+                <div dojoType="dijit.layout.TabContainer" style="width: 100%; height: 100%;padding:2px;">
+                    <div dojoType="dijit.layout.ContentPane" title="Chat" region="center" style="width:95%;height:100%">
+                        <div dojoType="dijit.layout.BorderContainer" style="width: 100%; height: 100%;">
+                            <div dojoType="dijit.layout.ContentPane" region="top" style="height: 50px; background: #999999;">
+                                XMPP Test Client
+                                <div style="top:10px; float: right;">
+                                    Status: <select dojoType="dijit.form.FilteringSelect" id="presence" name="presence" autoComplete="false" onChange="updatePresence(arguments[0]);">
+                                        <option value="available" selected>Online</option>
+                                        <option value="away">Away</option>
+                                        <option value="chat">Free to Chat</option>
+                                        <option value="dnd">Do Not Disturb</option>
+                                        <option value="xa">Extended Away</option>
+                                    </select>
+                                            <button dojoType="dijit.form.Button" id="addUserButton" onClick="showAddBuddy()">Add Buddy</button>
+                                </div>
+                            </div>
+
+                            <div id="buddyListCP" dojoType="dijit.layout.ContentPane" region="right" style="width: 200px; border: 1px solid #999999; overflow:auto;">
+
+                                <div id="buddyList">
+                                </div>
+                            </div>
+                            <div id="chatTabs" dojoType="dijit.layout.TabContainer" region="center" style="border: 1px solid #999999; height:100%"></div>
+                        </div>
+                    </div>
+                    <!-- MUC Container -->
+                    <div dojoType="dijit.layout.BorderContainer" id="confTab" title="Conference" style="width: 100%; height: 100%;">
+                        <div dojoType="dijit.layout.ContentPane" region="top" style="height: 50px; background: #999999;">
+                            XEP-124 Test MUC Client
+                            <select dojoType="dijit.form.ComboBox" id="confAction" name="confAct" onChange="execConfAction(arguments[0])" style="margin-top:10px; float: right;">
+                                <option id="dummy" value="Dummy" selected="selected">Select Action</option>
+                                <option value="Join">Join</option>
+                                <option value="Invite">Invite</option>
+                                <option value="Leave">Leave</option>
+                                <option value="Destroy">Destroy</option>
+                            </select>
+                            <input dojoType="dijit.form.ComboBox" store="options" value="Select Room" id="confSel" name="conf" autoComplete="false" style="margin-top:10px; float: right;" />
+                            <!--input type="button" name="Create" value="Create" onclick="createInstantRoom()" style="margin:12px 5px 0 0; float: right;" / -->
+							<div dojoType="dijit.form.DropDownButton" dojoAttachPoint="btn_Create" style="float:right;margin-top:10px;padding-right:10px">
+								<span>Create</span>
+								<div dojoType="dijit.Menu" toggle="fade">
+									<div dojoType="dijit.MenuItem"										
+										onClick="createInstantRoom()">
+										Instant Room
+									</div>
+									<div dojoType="dijit.MenuItem"										
+										onClick="createReservedRoom()">
+										Reserved Room
+									</div>
+								</div>
+							</div>
+                        </div>
+                        <div id="mucTabs" dojoType="dijit.layout.TabContainer" region="center" style="border: 1px solid #999999;">
+                        </div>
+                        <div dojoType="dijit.Dialog" id="confDialog" style="display: none; width:300px" title="Conference Disabled">
+                            <table>
+                                <tr>
+                                    <td align="center"><span>Conferencing is not available on the server</span></td>
+                                </tr>
+                                <tr>
+                                    <td align="center">
+                                        <button dojoType="dijit.form.Button" onclick="isMUCEnabled()" type="button">Check Again</button>
+                                    </td>
+                                </tr>
+                            </table>
+                        </div>
+                    </div>
+                </div>
+            </div>
+    </body>
 </html>
+
Index: dojo-release-1.3.2-src/dojox/xmpp/widget/MUCSession.js
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ dojo-release-1.3.2-src/dojox/xmpp/widget/MUCSession.js	2010-01-04 11:09:32.000000000 +0530
@@ -0,0 +1,104 @@
+dojo.provide("dojox.xmpp.widget.MUCSession");
+
+dojo.require("dojo.date");
+dojo.require("dojo.date.locale");
+dojo.require("dojo.date.stamp");
+
+dojo.declare("dojox.xmpp.widget.MUCSession",
+	[dijit.layout.LayoutContainer, dijit._Templated],
+	{
+		templatePath: dojo.moduleUrl("dojox.xmpp.widget", "templates/MUCSession.html"),
+		enableSubWidgets: true,
+		widgetsInTemplate: true,
+			
+		widgetType: "MUCSession",
+		room: null,
+		instance: null,
+		session: null, //xmppSession
+		mucManager: null,		
+		titlePane: null,
+		connects : [],
+			
+		postCreate: function(){
+			
+		},
+
+		joinRoom: function() {
+			this.instance.joinRoom();
+		},
+	
+		displayMessage: function(message) {
+			//console.log("displayMessage", this, message);
+			if(message) {
+				var nick = this.session.getResourceFromJid(message.from);
+				var name =  (nick == this.instance.nickname) ? "me" : nick;
+				var delay="";
+				if(message.delay)
+                   delay = "("+dojo.date.locale.format(dojo.date.stamp.fromISOString(message.delay))+")";
+				this.messages.domNode.innerHTML += "<b>" + name + delay +":</b> " +   message.body + "<br/>";
+				this.goToLastMessage();
+			}
+				
+		},
+			
+		goToLastMessage: function() {
+			this.messages.domNode.scrollTop = this.messages.domNode.scrollHeight;
+		},
+			
+		onKeyPress: function(e){
+			var key = e.keyCode || e.charCode;
+			if ((key == dojo.keys.ENTER) && (this.chatInput.value != "")){
+				this.instance.sendMessage({
+					body: this.chatInput.value
+					}, "groupchat");
+				this.chatInput.value = "";
+			}
+		},
+
+		createRoster: function(roster) {
+			//console.log("Widget::createRoster called for "+this.room);
+			var rosterDiv = document.createElement("div");
+			this.mucRoster.appendChild(rosterDiv);
+			var buffer = new dojox.string.Builder();
+			var rItem;
+			for(var item in roster){
+				rItem = roster[item];
+				console.log("Roster item->"+rItem.nickName);				
+				buffer.append('<div imcontactid="'+rItem.nickName+'" style="width:15em">'+
+						'<div class="dijitInline presence online"></div>'+
+						'<div class="dijitInline" style="padding-left:5px;width:10em">'+rItem.nickName+'</div>');
+				if(this.instance.isOwner() && rItem != this.instance.getSelfOccupancy()){
+					buffer.append('<div title="kick" class="dijitInline presence away" onclick="kick(\''+rItem.nickName+'\',\''+this.instance.uid+'\')"/>');
+				}
+				buffer.append('</div>');
+			}
+			rosterDiv.innerHTML = buffer.toString();
+			this.titlePane = new dijit.TitlePane({
+				title: "Participants"
+			}, rosterDiv);			
+		},		
+
+		updateRoster: function(nick, occupant) {
+			var newOcc = this.instance.roster[nick];
+			if(nick == this.instance.nickname) return;
+			if(newOcc && newOcc.presence.type == 'unavailable'){ // occupant leaves room
+				dojo.query('div[imContactId="'+nick+'"]', this.mucRoster).forEach(function(buddy) {
+						buddy.parentNode.removeChild(buddy);
+				 });
+				this.instance.removeFromRoster(newOcc);
+				this.messages.domNode.innerHTML += "<i>" + nick + " left this room</i><br/>";
+			}else if(occupant == null){ //when a new user joins occupant object will be null
+				var buffer = new dojox.string.Builder();
+				buffer = buffer.append(this.titlePane.containerNode.innerHTML);
+				buffer.append('<div imcontactid="'+newOcc.nickName+'">'+
+					'<div class="dijitInline presence online"></div>'+						
+						'<div class="dijitInline" style="padding-left:5px;width:10em">'+newOcc.nickName+'</div>');
+				if(this.instance.isOwner()){
+					buffer.append('<div title="kick" class="dijitInline presence away" onclick="kick(\''+newOcc.nickName+'\',\''+this.instance.uid+'\')"/>');
+				}
+				buffer.append('</div>');
+				this.titlePane.containerNode.innerHTML = buffer.toString();
+				this.messages.domNode.innerHTML += "<i>" + newOcc.nickName + " joined this room</i><br/>";
+			}
+		}		
+	});
\ No newline at end of file
Index: dojo-release-1.3.2-src/dojox/xmpp/widget/templates/ChatSession.html
===================================================================
--- dojo-release-1.3.2-src.orig/dojox/xmpp/widget/templates/ChatSession.html	2010-01-04 11:09:30.000000000 +0530
+++ dojo-release-1.3.2-src/dojox/xmpp/widget/templates/ChatSession.html	2010-01-04 11:09:32.000000000 +0530
@@ -1,5 +1,5 @@
 <div>
-<div dojoAttachPoint="messages" dojoType="dijit.layout.ContentPane" layoutAlign="client" style="overflow:auto">
+<div dojoAttachPoint="messages" dojoType="dijit.layout.ContentPane" layoutAlign="client" style="height:90%;overflow:auto">
 </div>
-<div dojoType="dijit.layout.ContentPane" layoutAlign="bottom" style="border-top: 2px solid #333333; height: 35px;"><input dojoAttachPoint="chatInput" dojoAttachEvent="onkeypress: onKeyPress" style="width: 100%;height: 35px;" /></div>
+<div dojoType="dijit.layout.ContentPane" layoutAlign="bottom" style="border-top: 2px solid #333333; height: 10%; overflow:hidden;"><input dojoAttachPoint="chatInput" dojoAttachEvent="onkeypress: onKeyPress" style="width: 100%;height: 35px;" /></div>
 </div>
\ No newline at end of file
Index: dojo-release-1.3.2-src/dojox/xmpp/widget/templates/MUCSession.html
===================================================================
--- /dev/null	1970-01-01 00:00:00.000000000 +0000
+++ dojo-release-1.3.2-src/dojox/xmpp/widget/templates/MUCSession.html	2010-01-04 11:09:32.000000000 +0530
@@ -0,0 +1,13 @@
+<div>
+	<div dojoType="dijit.layout.ContentPane" layoutAlign="right" style="float:right;width:20%; height:90%; border: 1px solid #999999;">
+		<div id="mucRosterID" dojoAttachPoint="mucRoster" style="padding:10px">			
+		</div>
+	</div>
+	<div dojoType="dijit.layout.ContentPane" dojoAttachPoint="messages" style="float:left;width:79%;height:90%; padding-right:1px;">
+		
+	</div>
+	<div dojoType="dijit.layout.ContentPane" layoutAlign="bottom" style="width:100%;height:9%; overflow:hidden; padding-right:1px;">
+		<input  dojoAttachPoint="chatInput" dojoAttachEvent="onkeypress: onKeyPress" type="text" style="width:100%;height:100%"/>
+	</div>
+	
+</div>
\ No newline at end of file
Index: dojo-release-1.3.2-src/dojox/xmpp/xmppSession.js
===================================================================
--- dojo-release-1.3.2-src.orig/dojox/xmpp/xmppSession.js	2010-01-04 11:09:30.000000000 +0530
+++ dojo-release-1.3.2-src/dojox/xmpp/xmppSession.js	2010-01-28 18:23:04.000000000 +0530
@@ -5,6 +5,7 @@
 dojo.require("dojox.xmpp.PresenceService");
 dojo.require("dojox.xmpp.UserService");
 dojo.require("dojox.xmpp.ChatService");
+dojo.require("dojox.xmpp.MUCManager");
 dojo.require("dojox.xmpp.sasl");
 
 dojox.xmpp.xmpp = {
@@ -14,7 +15,8 @@
 	SASL_NS: 'urn:ietf:params:xml:ns:xmpp-sasl',
 	BIND_NS: 'urn:ietf:params:xml:ns:xmpp-bind',
 	BODY_NS: "http://jabber.org/protocol/httpbind",
-	
+	MUC_NS: "http://jabber.org/protocol/muc",
+
 	XHTML_BODY_NS: "http://www.w3.org/1999/xhtml",
 	XHTML_IM_NS: "http://jabber.org/protocol/xhtml-im",
 
@@ -23,6 +25,8 @@
 	ACTIVE: "Active",
 	TERMINATE: "Terminate",
 	LOGIN_FAILURE: "LoginFailure",
+	DELAY_NS:"urn:xmpp:delay",
+    IQ_PRIVATE_NS: "jabber:iq:private",
 
 	INVALID_ID: -1,
 	NO_ID: 0,
@@ -52,7 +56,7 @@
 		dojo.mixin(this, props);
 	}
 
-	this.session = new dojox.xmpp.TransportSession(props); 
+	this.session = new dojox.xmpp.TransportSession(props);
 	dojo.connect(this.session, "onReady", this, "onTransportReady");
 	dojo.connect(this.session, "onTerminate", this, "onTransportTerminate");
 	dojo.connect(this.session, "onProcessProtocolResponse", this, "processProtocolResponse");
@@ -65,7 +69,8 @@
 		chatRegister: [],
 		_iqId: Math.round(Math.random() * 1000000000),
 		services: [],
-	
+        mucManager: null,
+
 		open: function(user, password, resource){
 
 			if (!user) {
@@ -93,7 +98,7 @@
 
 		close: function(){
 			this.state = dojox.xmpp.xmpp.TERMINATE;
-			this.session.close(dojox.xmpp.util.createElement("presence",{type:"unavailable",xmlns:dojox.xmpp.xmpp.CLIENT_NS},true));	
+			this.session.close(dojox.xmpp.util.createElement("presence",{type:"unavailable",xmlns:dojox.xmpp.xmpp.CLIENT_NS},true));
 		},
 
 		processProtocolResponse: function(msg){
@@ -114,23 +119,24 @@
 					//console.log("default action?", msg.getAttribute('xmlns'));
 					if(msg.getAttribute('xmlns')==dojox.xmpp.xmpp.SASL_NS){
 						this.saslHandler(msg);
-					}	
+					}
 			}
 		},
 
-		//HANDLERS 
+		//HANDLERS
 
 		messageHandler: function(msg){
 			//console.log("xmppSession::messageHandler() ",msg);
 			switch(msg.getAttribute('type')){
+                case "groupchat":
 				case "chat":
 					this.chatHandler(msg);
 					break;
 				case "normal":
 				default:
-					this.simpleMessageHandler(msg);	
+					this.simpleMessageHandler(msg);
 			}
-			
+
 		},
 
 		iqHandler: function(msg){
@@ -146,6 +152,10 @@
 
 		presenceHandler: function(msg){
 			//console.log("xmppSession::presenceHandler()");
+            if(this.mucManager && this.mucManager._isMUC(msg)){ // if its from a MUC service, delegate and return
+                this.mucManager._handlePresence(msg);
+                return;
+            }
 			switch(msg.getAttribute('type')){
 				case 'subscribe':
 					//console.log("PresenceHandler: ", msg.getAttribute('from'));
@@ -154,7 +164,7 @@
 				case 'subscribed':
 				case 'unsubscribed':
 					break;
-				case 'error':		
+				case 'error':
 					this.processXmppError(msg);
 					//console.log("xmppService::presenceHandler() Error");
 					break;
@@ -185,13 +195,13 @@
 								hasBindFeature = true;
 						//	}
 							break;
-					}	
+					}
 				}
 			}
 			//console.log("Has connected/bind?", this.state, hasBindFeature, authMechanisms);
 			if (this.state == dojox.xmpp.xmpp.CONNECTED && hasBindFeature){
 				for(var i=0; i<authMechanisms.length; i++){
-					
+
 					if (authMechanisms[i]=="SUN-COMMS-CLIENT-PROXY-AUTH"){
 						dojox.xmpp.sasl.SunWebClientAuth(this);
 						break;
@@ -203,7 +213,7 @@
 					}
 				}
 
-				//delete the pass from memory so its not just sitting around waiting for 
+				//delete the pass from memory so its not just sitting around waiting for
 				//people to snatch it
 				delete this.password;
 			}
@@ -263,6 +273,9 @@
 				if(n.getAttribute('xmlns')==dojox.xmpp.chat.CHAT_STATE_NS){
 					chatState = n.nodeName;
 				}*/
+				if(n.getAttribute('xmlns')==dojox.xmpp.xmpp.DELAY_NS){
+					message.delay = n.getAttribute("stamp");
+				}
 			}
 
 			var found = -1;
@@ -272,19 +285,20 @@
 					////console.log("ci.chatid: ", ci.chatid, message.chatid);
 					if (ci && ci.chatid == message.chatid) {
 						found = i;
-						break;	
+						break;
 					}
 				}
-			} else {
+			}
+            if(found == -1) {
 				for (var i=0; i< this.chatRegister.length; i++){
 					var ci = this.chatRegister[i];
 					if(ci){
-						if (ci.uid==this.getBareJid(message.from)){
+						if (ci.uid.toLowerCase()==this.getBareJid(message.from).toLowerCase()){
 							found = i;
 						}
 					}
 				}
-			}	
+			}
 
 			if (found>-1 && chatState){
 				var chat = this.chatRegister[found];
@@ -293,10 +307,10 @@
 				if (chat.firstMessage){
 					if (chatState == dojox.xmpp.chat.ACTIVE_STATE) {
 						chat.useChatState = (chatState != null) ? true : false;
-						chat.firstMessage = false;	
+						chat.firstMessage = false;
 					}
 				}
-			} 
+			}
 
 			if ((!message.body || message.body=="") && !message.xhtml) {return;}
 
@@ -317,6 +331,9 @@
 
 		simpleMessageHandler: function(msg){
 			//console.log("xmppSession::simpleMessageHandler() ", msg);
+            if(this.mucManager && this.mucManager._isMUC(msg)){
+                this.mucManager._handleMUCSimpleMessage(msg);
+            }
 		},
 
 		registerChatInstance: function(chatInstance, message){
@@ -325,7 +342,14 @@
 			this.onRegisterChatInstance(chatInstance, message);
 			chatInstance.recieveMessage(message,true);
 		},
-		
+
+        registerMUCInstance: function(mucInstance, message){
+			mucInstance.setSession(this);
+			this.chatRegister.push(mucInstance);
+			this.mucManager.onRegisterChatInstance(mucInstance, message);
+			mucInstance.recieveMessage(message,true);
+		},
+
 		iqSetHandler: function(msg){
 			if (msg.hasChildNodes()){
 				var fn = msg.firstChild;
@@ -333,7 +357,7 @@
 					case 'query':
 						if(fn.getAttribute('xmlns') == "jabber:iq:roster"){
 							this.rosterSetHandler(fn);
-							this.sendIqResult(msg.getAttribute('id'), msg.getAttribute('from'));	
+							this.sendIqResult(msg.getAttribute('id'), msg.getAttribute('from'));
 						}
 						break;
 					default:
@@ -357,7 +381,7 @@
 			//console.log("xmppSession::rosterSetHandler()", arguments);
 			for (var i=0; i<elem.childNodes.length;i++){
 				var n = elem.childNodes[i];
-			
+
 				if (n.nodeName=="item"){
 					var found = false;
 					var state = -1;
@@ -387,19 +411,19 @@
 								var itemName = n.getAttribute('name');
 								if (itemName){
 									this.roster[x].name = itemName;
-								}	
+								}
 
 								r.groups = [];
 
 								if (n.getAttribute('subscription')){
 									r.status = n.getAttribute('subscription');
 								}
-						
+
 								r.substatus = dojox.xmpp.presence.SUBSCRIPTION_SUBSTATUS_NONE;
 								if(n.getAttribute('ask')=='subscribe'){
 									r.substatus = dojox.xmpp.presence.SUBSCRIPTION_REQUEST_PENDING;
 								}
-					
+
 								for(var y=0;y<n.childNodes.length;y++){
 									var groupNode = n.childNodes[y];
 									if ((groupNode.nodeName=='group')&&(groupNode.hasChildNodes())){
@@ -418,7 +442,7 @@
 						rosterItem = r;
 						state = dojox.xmpp.roster.ADDED;
 					}
-				
+
 					switch(state){
 						case dojox.xmpp.roster.ADDED:
 							this.onRosterAdded(rosterItem);
@@ -429,8 +453,8 @@
 						case dojox.xmpp.roster.CHANGED:
 							this.onRosterChanged(rosterItem, previousCopy);
 							break;
-					}	
-				}	
+					}
+				}
 			}
 		},
 
@@ -452,7 +476,7 @@
 				show: dojox.xmpp.presence.STATUS_ONLINE,
 				priority: 5,
 				hasAvatar: false
-			}	
+			}
 
 			if(msg.getAttribute('type')=='unavailable'){
 				p.show=dojox.xmpp.presence.STATUS_OFFLINE
@@ -470,14 +494,14 @@
 							p.priority=parseInt(n.firstChild.nodeValue);
 							break;
 						case 'x':
-							if(n.firstChild && n.firstChild.firstChild &&  n.firstChild.firstChild.nodeValue != "") { 
+							if(n.firstChild && n.firstChild.firstChild &&  n.firstChild.firstChild.nodeValue != "") {
 								p.avatarHash= n.firstChild.firstChild.nodeValue;
 								p.hasAvatar = true;
 							}
 							break;
 					}
 				}
-			}	
+			}
 
 			this.onPresenceUpdate(p);
 		},
@@ -496,7 +520,7 @@
 
 			var def = this.dispatchPacket(req,"iq", props.id);
 			def.addCallback(this, "onRetrieveRoster");
-			
+
 		},
 
 		getRosterIndex: function(jid){
@@ -519,13 +543,13 @@
 				status: dojox.xmpp.presence.SUBSCRIPTION_NONE,
 				substatus: dojox.xmpp.presence.SUBSCRIPTION_SUBSTATUS_NONE
 			//	displayToUser: false
-			}	
+			}
 
 			if (!re.name){
 				re.name = re.id;
 			}
-			
-			
+
+
 
 			for(var i=0; i<elem.childNodes.length;i++){
 				var n = elem.childNodes[i];
@@ -548,18 +572,18 @@
                                         }
                                     }
                                 }
-			} 
+			}
 
 			if (elem.getAttribute('subscription')){
 				re.status = elem.getAttribute('subscription');
-			}	
+			}
 
 			if (elem.getAttribute('ask')=='subscribe'){
 				re.substatus = dojox.xmpp.presence.SUBSCRIPTION_REQUEST_PENDING;
-			}	
+			}
 			//Display contact rules from http://www.xmpp.org/extensions/xep-0162.html#contacts
-		/*	if(re.status == dojox.xmpp.presence.SUBSCRIPTION_REQUEST_PENDING || 
-				re.status == dojox.xmpp.presence.SUBSCRIPTION_TO || 
+		/*	if(re.status == dojox.xmpp.presence.SUBSCRIPTION_REQUEST_PENDING ||
+				re.status == dojox.xmpp.presence.SUBSCRIPTION_TO ||
 				re.status == dojox.xmpp.presence.SUBSCRIPTION_BOTH ||
 				re.groups.length > 0 ||
 				re.name
@@ -635,7 +659,7 @@
 			if (this.state != state){
 				if (this["on"+state]){
 					this["on"+state](state, this.state, message);
-				}	
+				}
 				this.state=state;
 			}
 		},
@@ -682,19 +706,22 @@
 			request.append("</iq>");
 			var def = this.dispatchPacket(request.toString(),"iq",req.id);
 			def.addCallback(this, function(info) {
-			    if ((info.getAttribute('type')=='result')&&(info.hasChildNodes())){
-				var query = info.getElementsByTagName('query')[0];
-				if (query.getAttribute('xmlns')=="http://jabber.org/protocol/disco#info"){
-					for (var i=0;i<query.childNodes.length;i++){
-						var n = query.childNodes[i];
-						if (n.nodeName=="identity"){
-						    console.log("Service: " + jid + ", Category:" + n.getAttribute('category'));
-						    this.services[n.getAttribute('category')] = jid;
-						}
-					}
-				}
-			    }
-			});
+                if ((info.getAttribute('type')=='result')&&(info.hasChildNodes())){
+                    var query = info.getElementsByTagName('query')[0];
+                    var serviceId = "";
+                    if (query.getAttribute('xmlns')=="http://jabber.org/protocol/disco#info"){
+                        for (var i=0;i<query.childNodes.length;i++){
+                            var n = query.childNodes[i];
+                            if (n.nodeName=="identity"){
+                                serviceId = n.getAttribute('category');
+                                console.log("Service: " + jid + ", Category:" + serviceId);
+                                this.services[serviceId] = jid;
+                            }
+                        }
+                        this._onServiceDiscovered(serviceId);
+                    }
+                }
+            });
 		},
 
 		search: function(searchString, service, searchAttribute){
@@ -733,10 +760,55 @@
 			}
 		},
 
+		_onServiceDiscovered: function(serviceId){
+            if(serviceId === 'conference' && this.mucManager == null){
+                // intialize the MUCManager only if service is present
+                this.mucManager = new dojox.xmpp.MUCManager(this);
+                this.mucManager._setMUCService(this.services['conference']);
+                this.onMUCServiceReady(this.mucManager);
+            }
+        },
+
+        /**
+         * Implementation of storage part of XEP-0049 (Private XML Storage)
+         */
+        storeXML: function(xmlNode){
+            var req={
+				id: this.getNextIqId(),
+				"xml:lang": this.lang,
+				type: 'set'
+			}
+            var request = new dojox.string.Builder(dojox.xmpp.util.createElement("iq",req,false));
+			request.append(dojox.xmpp.util.createElement('query',{xmlns:dojox.xmpp.xmpp.IQ_PRIVATE_NS},false));
+            request.append(xmlNode.toString());
+            request.append("</query>");
+            request.append("</iq>");
+            var def = this.dispatchPacket(request.toString(),"iq",req.id);
+            return def;
+        },
+
+        /**
+         * Implementation of retrieve part of XEP-0049 (Private XML Storage)
+         */
+        retrieveXML: function(xmlNode){
+            var req={
+				id: this.getNextIqId(),
+				"xml:lang": this.lang,
+				type: 'get'
+			}
+            var request = new dojox.string.Builder(dojox.xmpp.util.createElement("iq",req,false));
+			request.append(dojox.xmpp.util.createElement('query',{xmlns:dojox.xmpp.xmpp.IQ_PRIVATE_NS},false));
+            request.append(xmlNode.toString());
+            request.append("</query>");
+            request.append("</iq>");
+            var def = this.dispatchPacket(request.toString(),"iq",req.id);
+            return def;
+        },
+
 		// EVENTS
 
-		onLogin: function(){ 
-			////console.log("xmppSession::onLogin()"); 
+		onLogin: function(){
+			////console.log("xmppSession::onLogin()");
 			this.retrieveRoster();
 			this.discoverServices();
 		},
@@ -747,7 +819,7 @@
 
 		onBindResource: function(msg){
 			//console.log("xmppSession::onBindResource() ", msg);
-		
+
 			if (msg.getAttribute('type')=='result'){
 				//console.log("xmppSession::onBindResource() Got Result Message");
 				if ((msg.hasChildNodes()) && (msg.firstChild.nodeName=="bind")){
@@ -763,8 +835,8 @@
 				}else{
 					//console.log("xmppService::onBindResource() No Bind Element Found");
 				}
-		
-				this.onLogin();	
+
+				this.onLogin();
 			}else if(msg.getAttribute('type')=='error'){
 				//console.log("xmppSession::onBindResource() Bind Error ", msg);
 				var err = this.processXmppError(msg);
@@ -789,18 +861,18 @@
 							this.roster[i] = this.createRosterEntry(query.childNodes[i]);
 						}
 					}
-				}	
+				}
 			}else if(msg.getAttribute('type')=="error"){
-				//console.log("xmppService::storeRoster()  Error recieved on roster get");	
+				//console.log("xmppService::storeRoster()  Error recieved on roster get");
 			}
 
 			////console.log("Roster: ", this.roster);
 			this.setState(dojox.xmpp.xmpp.ACTIVE);
 			this.onRosterUpdated();
 
-			return msg;	
+			return msg;
 		},
-		
+
 		onRosterUpdated: function() {},
 
 		onSubscriptionRequest: function(req){},
@@ -841,6 +913,8 @@
 		onRosterRemoved: function(ri){},
 		onRosterChanged: function(ri, previousCopy){},
 
+		onMUCServiceReady: function(mucManager){} /* MUC service found, mucManager=null if not found */,
+
 		//Utilities
 
 		processXmppError: function(msg){
@@ -849,7 +923,7 @@
 				stanzaType: msg.nodeName,
 				id: msg.getAttribute('id')
 			}
-	
+
 			for (var i=0; i<msg.childNodes.length; i++){
 				var n = msg.childNodes[i];
 				switch(n.nodeName){
@@ -857,7 +931,7 @@
 						err.errorType = n.getAttribute('type');
 						for (var x=0; x< n.childNodes.length; x++){
 							var cn = n.childNodes[x];
-							if ((cn.nodeName=="text") && (cn.getAttribute('xmlns') == dojox.xmpp.xmpp.STANZA_NS) && cn.hasChildNodes()) {	
+							if ((cn.nodeName=="text") && (cn.getAttribute('xmlns') == dojox.xmpp.xmpp.STANZA_NS) && cn.hasChildNodes()) {
 								err.message = cn.firstChild.nodeValue;
 							} else if ((cn.getAttribute('xmlns') == dojox.xmpp.xmpp.STANZA_NS) &&(!cn.hasChildNodes())){
 								err.condition = cn.nodeName;
@@ -867,16 +941,16 @@
 					default:
 						break;
 				}
-			}	
+			}
 			return err;
 		},
 
 		sendStanzaError: function(stanzaType,to,id,errorType,condition,text){
 			////console.log("xmppSession: sendStanzaError() ", arguments);
 			var req = {type:'error'};
-			if (to) { req.to=to; }	
-			if (id) { req.id=id; }	
-		
+			if (to) { req.to=to; }
+			if (id) { req.id=id; }
+
 			var request = new dojox.string.Builder(dojox.xmpp.util.createElement(stanzaType,req,false));
 			request.append(dojox.xmpp.util.createElement('error',{type:errorType},false));
 			request.append(dojox.xmpp.util.createElement('condition',{xmlns:dojox.xmpp.xmpp.STANZA_NS},true));