drawio/war/js/diagramly/DriveRealtime.js

/**
 * Copyright (c) 2006-2016, JGraph Ltd
 * Copyright (c) 2006-2016, Gaudenz Alder
 */
/**
 * Creates an object that synchronizes the graph model and given realtime model.
 * The session ID is used as a prefix in the model to produce unique IDs for new
 * cells.
 */
function DriveRealtime(file, doc)
{
	this.realtimeAutosaveDelay = this.defaultRealtimeAutosaveDelay;
	this.realtimeMaxAutosaveDelay = this.defaultRealtimeMaxAutosaveDelay;
	
	this.file = file;
	this.doc = doc;
	this.rtModel = this.doc.getModel();
	this.root = this.rtModel.getRoot();
	
	this.ui = file.getUi()
	this.graph = this.ui.editor.graph;
	this.model = this.graph.model;
	this.userId = this.ui.drive.user.id;

	this.ui.allowAnimation = false;
	this.codec = new mxCodec();
	
	this.disconnectListener = mxUtils.bind(this, function()
	{
		// LATER: How to reload realtime document without refreshing the page
		this.sessionExpiredError();
	});
	
	this.ui.drive.addListener('disconnected', this.disconnectListener);
	
	// Change of autosave triggers an immediate save to update thumbnail
	this.autosaveChangeListener = mxUtils.bind(this, function()
	{
		var prevValue = this.ui.drive.enableThumbnails;
		this.ui.drive.enableThumbnails = this.ui.editor.autosave;
		this.ui.editor.setStatus(mxResources.get('saving') + '...');
		
		this.file.save(true, mxUtils.bind(this, function()
		{
			this.ui.editor.setStatus(mxResources.get('allChangesSaved'));
		}));
		
		this.ui.drive.enableThumbnails = prevValue;
	});
	
	this.ui.editor.addListener('autosaveChanged', this.autosaveChangeListener);
};

/**
 * Specifies the key of the root element in the model. Default is root.
 */
DriveRealtime.prototype.logLevel = 2;

/**
 * True if a change event is fired for a remote change.
 */
DriveRealtime.prototype.updateStatusInterval = 20000;

/**
 * Specifies the key of the root element in the model. Default is root.
 */
DriveRealtime.prototype.diagramsKey = 'diagrams';

/**
 * Specifies the key of the root element in the model. Default is root.
 */
DriveRealtime.prototype.diagrams = null;

/**
 * Specifies the key of the root element in the model. Default is root.
 */
DriveRealtime.prototype.rootKey = 'root';

/**
 * Specifies the key of the root element in the model. Default is root.
 */
DriveRealtime.prototype.diagramMap = null;

/**
 * Specifies the key of the root element in the model. Default is root.
 */
DriveRealtime.prototype.chatHistory = null;

/**
 * True if a change event is fired for a remote change.
 */
DriveRealtime.prototype.saving = false;

/**
 * Sets the delay for autosave in milliseconds. Default is 5000.
 */
DriveRealtime.prototype.defaultRealtimeAutosaveDelay = 5000;

/**
 * Sets the delay for autosave in milliseconds. Default is 60000.
 */
DriveRealtime.prototype.defaultRealtimeMaxAutosaveDelay = 60000;

/**
 * Sets the delay for autosave in milliseconds. Default is 500.
 */
DriveRealtime.prototype.realtimeHeartbeat = 30000;

/**
 * True if a undoableEdit has been scheduled in <executeChange>.
 */
DriveRealtime.prototype.ignoreChange = false;

/**
 * True if a undoableEdit has been scheduled in <executeChange>.
 */
DriveRealtime.prototype.ignorePageFormatChanged = false;

/**
 * True if a undoableEdit has been scheduled in <executeChange>.
 */
DriveRealtime.prototype.ignoreScaleChanged = false;

/**
 * True if a undoableEdit has been scheduled in <executeChange>.
 */
DriveRealtime.prototype.ignoreBackgroundColorChanged = false;

/**
 * True if a undoableEdit has been scheduled in <executeChange>.
 */
DriveRealtime.prototype.ignoreShadowVisibleChanged = false;

/**
 * True if a undoableEdit has been scheduled in <executeChange>.
 */
DriveRealtime.prototype.ignoreBackgroundImageChanged = false;

/**
 * True if a undoableEdit has been scheduled in <executeChange>.
 */
DriveRealtime.prototype.ignoreMathEnabledChanged = false;

/**
 * Syncs initial state from collab model to graph model.
 */
DriveRealtime.prototype.getDiagramMap = function()
{
	return (this.ui.currentPage != null) ? this.ui.currentPage.mapping.diagramMap : this.diagramMap;
};

/**
 * Indirection for legacy support.
 */
DriveRealtime.prototype.getCurrentPage = function()
{
	return (this.page != null) ? this.page : this.ui.currentPage;
};

/**
 * Synchronizes the collaboration model and the graph model and installs
 * the required listeners to keep them in sync.
 */
DriveRealtime.prototype.start = function()
{
	if (urlParams['reset'] == '1')
	{
		this.root.clear();
		this.log('reset realtime');
	}

	var prefix = this.createPrefix();
	this.model.prefix = prefix + '-';
	this.ui.editor.resetGraph();
		
	// Creates diagrams list and default entry
	this.diagrams = this.root.get(this.diagramsKey);
	var diagramsCreated = false;
	
	if (this.diagrams == null)
	{
		this.diagrams = this.rtModel.createList();
		this.root.set(this.diagramsKey, this.diagrams);
		diagramsCreated = true;
		this.log('realtime model initialized');
	}
	
	// Specifies if the file should be saved immediately after setup
	var forceSave = false;
	
	if (this.file.getData() != '')
	{
		this.ui.fileNode = null;
		this.ui.pages = null;
		
		// Converts from XML to realtime
    	this.ui.setFileData(this.file.getData());
    	this.log('xml converted');
    	
    	// Logs conversion of old RT models (converted from XML backup)
    	if (this.root.has('cells') && diagramsCreated)
    	{
	    	try
	    	{
				var img = new Image();
				
				// Timestamp is added to bypass client-side cache
				img.src = 'log?severity=CONFIG&msg=converted-oldrt&v=' +
					encodeURIComponent(EditorUi.VERSION) + '&ts=' + new Date().getTime();
	    	}
	    	catch (e)
	    	{
	    		// ignore
	    	}
    	}
    	
		if (this.ui.pages != null)
		{
			for (var i = 0; i < this.ui.pages.length; i++)
			{
				var page = this.ui.pages[i];
				
				var diagramMap = this.rtModel.createMap();
				this.diagrams.push(diagramMap);
				
				this.ui.updatePageRoot(page);
				page.mapping = new RealtimeMapping(this, diagramMap, page);
				
				if (this.file.isEditable())
				{
					// Read or create name for page
					if (page.getName() != '')
					{
						diagramMap.set('name', page.getName());
					}
					else if (!diagramMap.has('name'))
					{
						diagramMap.set('name', mxResources.get('pageWithNumber', [i + 1]));
					}
				}

				// Sync name and initialize
				page.setName(diagramMap.get('name') || mxResources.get('pageWithNumber', [i + 1]));
				page.mapping.init();
			}
		}
		else if (urlParams['pages'] != '1')
		{
			this.diagramMap = this.rtModel.createMap();
			this.diagrams.push(this.diagramMap);
			// Dummy node, should be XML node if used
			this.page = new DiagramPage(document.createElement('diagram'));
			this.page.mapping = new RealtimeMapping(this, this.diagramMap, this.page);
			this.page.mapping.init();
		}
		else
		{
			this.ui.fileNode = mxUtils.createXmlDocument().createElement('mxfile');
			this.ui.pages = [];
			
			var diagramMap = this.rtModel.createMap();
			this.diagrams.push(diagramMap);
			
			var page = new DiagramPage(this.ui.fileNode.ownerDocument.createElement('diagram'));
			page.mapping = new RealtimeMapping(this, diagramMap, page);
			this.ui.currentPage = page;

			if (this.file.isEditable() && !page.mapping.diagramMap.has('name'))
			{
				page.mapping.diagramMap.set('name', mxResources.get('pageWithNumber', [1]));
			}
			
			page.setName(page.mapping.diagramMap.get('name') || mxResources.get('pageWithNumber', [1]));
			this.ui.pages.push(page);
			page.mapping.init();
		}
		
		forceSave = true;
	}
	else if (this.diagrams.length < 2 && urlParams['pages'] != '1')
	{
		this.ui.fileNode = null;
		this.ui.pages = null;
		
		if (this.diagrams.length == 0)
		{
			this.diagramMap = this.rtModel.createMap();
			this.diagrams.push(this.diagramMap);
		}
		else
		{
			this.diagramMap = this.diagrams.get(0);
		}
		
		// Dummy node, should be XML node if used
		this.page = new DiagramPage(document.createElement('diagram'));
		this.page.mapping = new RealtimeMapping(this, this.diagramMap, this.page);
		
		// Avoids scroll offset when switching page
		this.page.mapping.init();
		this.ui.editor.fireEvent(new mxEventObject('resetGraphView'));
	}
	else
	{
		this.ui.fileNode = mxUtils.createXmlDocument().createElement('mxfile');
		this.ui.pages = [];
		
		if (this.diagrams.length == 0)
		{
			this.diagrams.push(this.rtModel.createMap());
		}
		
		var pageIndex = Math.max(0, Math.min(this.diagrams.length - 1, urlParams['page'] || 0));
		
		for (var i = 0; i < this.diagrams.length; i++)
		{
			var page = new DiagramPage(this.ui.fileNode.ownerDocument.createElement('diagram'));
			page.mapping = new RealtimeMapping(this, this.diagrams.get(i), page);
			
			if (this.file.isEditable() && !page.mapping.diagramMap.has('name'))
			{
				page.mapping.diagramMap.set('name', mxResources.get('pageWithNumber', [i + 1]));
			}
			
			page.setName(page.mapping.diagramMap.get('name') || mxResources.get('pageWithNumber', [i + 1]));
			this.ui.pages.push(page);
		}

		// Sets the current page
		this.ui.currentPage = this.ui.pages[Math.max(0, Math.min(this.ui.pages.length - 1, urlParams['page'] || 0))];;
		
		// Initializes graphs and mappings
		for (var i = 0; i < this.ui.pages.length; i++)
		{
			this.ui.pages[i].mapping.init();
		}
	}

	this.installReadOnlyListener();
	this.installUiChangeListeners();
	this.installGraphModelListener();
	this.installPageSelectListener();

	this.chatHistory = this.root.get('chatHistory');
	
	if (this.chatHistory == null)
	{
		this.initializeChat();
	}
	
	this.installSelectionModelListener();
	this.installCollaboratorListener();
	this.updateCollaborators();
	
	this.doc.addEventListener(gapi.drive.realtime.EventType.DOCUMENT_SAVE_STATE_CHANGED, mxUtils.bind(this, function(evt)
	{
		if (this.saving && !evt.isPending && !evt.isSaving && !forceSave)
		{
			// Checks if the mime type of the file has changed on the server-side
			// when the autosave is triggered to make sure we eventually check
			// the mime type even if the user continues to change the diagram
			// within the autosave interval, which will cancel the current thread.
			if (this.ui.isLegacyDriveDomain() && urlParams['ignoremime'] != '1')
			{
				this.ui.drive.verifyMimeType(this.file.getId());
			}

			// Adds tooltip to small spinner and saves a backup XML copy of the file
			if (this.file.isAutosave())
			{
				this.triggerAutosave();
			}
			else
			{
				this.ui.editor.setStatus(mxResources.get('allChangesSaved'));
			}
			
			this.saving = false;
			this.resetUpdateStatusThread();
			this.realtimeHeartbeat = DriveRealtime.prototype.realtimeHeartbeat;
			
			if (this.isAliveThread != null)
			{
				window.clearTimeout(this.isAliveThread);
				this.isAliveThread = null;
			}
		}
	}));
	
	var initialized = mxUtils.bind(this, function()
	{
		this.resetUpdateStatusThread();
		this.ui.resetScrollbars();
		this.updateStatus();
		forceSave = false;
	});

	// Updates backup and preview
	if (forceSave)
	{
		this.ui.editor.setStatus(mxResources.get('saving') + '...');
		this.file.save(false, initialized, initialized);
	}
	else
	{
		initialized();
	}

	// Implements separate undo history for each client
	if (this.previousUndoListener == null)
	{
		this.previousUndoListener = this.ui.editor.undoListener;
		this.ui.editor.undoListener = mxUtils.bind(this, function(sender, evt)
		{
			if (!this.ignoreChange)
			{
				this.previousUndoListener.apply(this, arguments);
			}
		});
	}
};

/**
 * Syncs initial state from graph model to collab model.
 */
DriveRealtime.prototype.triggerAutosave = function()
{
	this.ui.editor.setStatus(mxResources.get('updatingPreview'));
	
	this.file.autosave(this.realtimeAutosaveDelay, this.realtimeMaxAutosaveDelay, mxUtils.bind(this, function(resp)
	{					
		// Updates autosave delay to take into account actual delay
		this.realtimeAutosaveDelay = this.defaultRealtimeAutosaveDelay + Math.min(10000, this.file.saveDelay);
		
		// Does not update status if another autosave was scheduled
		if (this.ui.getCurrentFile() == this.file && !this.saving)
		{
			this.ui.editor.setStatus(mxResources.get('allChangesSaved'));
		}
	}),
	mxUtils.bind(this, function(resp)
	{
		this.ui.editor.setStatus(mxResources.get('errorUpdatingPreview'));
		
		// Handles error where mime type cannot be overridden because it has been changed by another app and no
		// new revision was created. This happens eg. if draw.io pro overwrites the mime type and adds a new realtime
		// model to the file which is not visible for this app so we need to switch app to stay connected to RT.
		// This could be improved to let the RT viewers know that the realtime is no longer valid, but currently
		// the focus is on not losing data, so only clients that write to the file are being notified with this.
		if (this.ui.isLegacyDriveDomain() && urlParams['ignoremime'] != '1' && resp != null &&
			resp.error != null && (resp.error.code == 400 || resp.error.code == 403))
		{	
			this.ui.drive.verifyMimeType(this.file.getId(), null, true);
		}
	}));
};

/**
 * Syncs initial state from graph model to collab model.
 */
DriveRealtime.prototype.triggerAutosave = function()
{
	this.ui.editor.setStatus(mxResources.get('updatingPreview'));
	
	this.file.autosave(this.realtimeAutosaveDelay, this.realtimeMaxAutosaveDelay, mxUtils.bind(this, function(resp)
	{
		// Updates autosave delay to take into account actual delay
		this.realtimeAutosaveDelay = this.defaultRealtimeAutosaveDelay + Math.min(10000, this.file.saveDelay);
		
		// Does not update status if another autosave was scheduled
		if (this.ui.getCurrentFile() == this.file && !this.saving)
		{
			this.ui.editor.setStatus(mxResources.get('allChangesSaved'));
		}
	}),
	mxUtils.bind(this, function(resp)
	{
		this.ui.editor.setStatus(mxResources.get('errorUpdatingPreview'));
		
		// Handles error where mime type cannot be overridden because it has been changed by another app and no
		// new revision was created. This happens eg. if draw.io pro overwrites the mime type and adds a new realtime
		// model to the file which is not visible for this app so we need to switch app to stay connected to RT.
		// This could be improved to let the RT viewers know that the realtime is no longer valid, but currently
		// the focus is on not losing data, so only clients that write to the file are being notified with this.
		if (this.ui.isLegacyDriveDomain() && urlParams['ignoremime'] != '1' && resp != null &&
			resp.error != null && (resp.error.code == 400 || resp.error.code == 403))
		{	
			this.ui.drive.verifyMimeType(this.file.getId(), null, true);
		}
	}));
};

/**
 * Syncs initial state from graph model to collab model.
 */
DriveRealtime.prototype.installReadOnlyListener = function()
{
	// Handles change of read-only state
	this.doc.addEventListener(gapi.drive.realtime.EventType.ATTRIBUTE_CHANGED, mxUtils.bind(this, function(evt)
	{
		if (evt.attribute == 'is_read_only')
		{
			this.file.descriptorChanged();
			
			if (!this.file.isEditable())
			{
				this.ui.editor.graph.reset();
				this.ui.editor.setStatus(mxResources.get('readOnly'));
			}
			else
			{
				this.ui.editor.setStatus('');
			}
		}
	}));
};

/**
 * Syncs initial state from graph model to collab model.
 */
DriveRealtime.prototype.installUiChangeListeners = function()
{
	this.pageFormatListener = mxUtils.bind(this, function(sender, evt)
	{
		if (!this.ignorePageFormatChanged)
		{
			try
			{
				this.setFileModified();
				this.getDiagramMap().set('pageFormat', this.graph.pageFormat.width + ',' + this.graph.pageFormat.height);
			}
			catch (e)
			{
				this.ui.handleError(e);
			}
		}
	});
	
	this.ui.addListener('pageFormatChanged', this.pageFormatListener);
	
	this.pageScaleListener = mxUtils.bind(this, function(sender, evt)
	{
		if (!this.ignorePageScaleChanged)
		{
			try
			{
				this.setFileModified();
				this.getDiagramMap().set('pageScale', this.graph.pageScale);
			}
			catch (e)
			{
				this.ui.handleError(e);
			}
		}
	});
	
	this.ui.addListener('pageScaleChanged', this.pageScaleListener);
	
	this.backgroundColorListener = mxUtils.bind(this, function(sender, evt)
	{
		if (!this.ignoreBackgroundColorChanged)
		{
			try
			{
				this.setFileModified();
				this.getDiagramMap().set('backgroundColor', (this.graph.background != null) ? this.graph.background : '');
			}
			catch (e)
			{
				this.ui.handleError(e);
			}
		}
	});
	
	this.ui.addListener('backgroundColorChanged', this.backgroundColorListener);
	
	this.shadowVisibleListener = mxUtils.bind(this, function(sender, evt)
	{
		if (!this.ignoreShadowVisibleChanged)
		{
			// Special case: This listener is called after switching page
			// so we check if the value has actually changed
			if (this.getDiagramMap().get('shadowVisible') != ((this.graph.shadowVisible) ? '1' : '0'))
			{
				try
				{
					this.setFileModified();
					this.getDiagramMap().set('shadowVisible', (this.graph.shadowVisible) ? '1' : '0');
				}
				catch (e)
				{
					this.ui.handleError(e);
				}
			}
		}
	});
	
	this.graph.addListener('shadowVisibleChanged', this.shadowVisibleListener);
	
	this.foldingEnabledListener = mxUtils.bind(this, function(sender, evt)
	{
		if (!this.ignoreFoldingEnabledChanged)
		{
			try
			{
				this.setFileModified();
				this.getDiagramMap().set('foldingEnabled', (this.graph.foldingEnabled) ? '1' : '0');
			}
			catch (e)
			{
				this.ui.handleError(e);
			}
		}
	});
	
	this.ui.addListener('foldingEnabledChanged', this.foldingEnabledListener);
	
	this.backgroundImageListener = mxUtils.bind(this, function(sender, evt)
	{
		if (!this.ignoreBackgroundImageChanged)
		{
			try
			{
				this.setFileModified();
				this.getDiagramMap().set('backgroundImage', (this.graph.backgroundImage != null) ? JSON.stringify(this.graph.backgroundImage) : '');
			}
			catch (e)
			{
				this.ui.handleError(e);
			}
		}
	});
	
	this.ui.addListener('backgroundImageChanged', this.backgroundImageListener);
	
	this.mathEnabledListener = mxUtils.bind(this, function(sender, evt)
	{
		if (!this.ignoreMathEnabledChanged)
		{
			try
			{
				this.setFileModified();
				this.getDiagramMap().set('mathEnabled', (this.graph.mathEnabled) ? '1' : '0');
			}
			catch (e)
			{
				this.ui.handleError(e);
			}
		}
	});
	
	this.ui.addListener('mathEnabledChanged', this.mathEnabledListener);
};

/**
 * Returns true if the given event is local.
 */
DriveRealtime.prototype.isLocalEvent = function(evt)
{
	return evt.isLocal;
};

/**
 * Syncs initial state from graph model to collab model.
 */
DriveRealtime.prototype.resetUpdateStatusThread = function()
{
	if (this.updateStatusThread != null)
	{
		window.clearInterval(this.updateStatusThread);
	}
	
	this.updateStatusThread = window.setInterval(mxUtils.bind(this, function()
	{
		this.ui.drive.checkToken(mxUtils.bind(this, function()
		{
			this.updateStatus();
		}));
	}), this.updateStatusInterval);
};

/**
 * Translates this point by the given vector.
 * 
 * @param {number} dx X-coordinate of the translation.
 * @param {number} dy Y-coordinate of the translation.
 */
DriveRealtime.prototype.timeSince = function(date)
{
    var seconds = Math.floor((new Date() - date) / 1000);
	
    var interval = Math.floor(seconds / 31536000);

    if (interval > 1)
    {
        return interval + ' ' + mxResources.get('years');
    }
    
    interval = Math.floor(seconds / 2592000);
    
    if (interval > 1)
    {
        return interval + ' ' + mxResources.get('months');
    }
    
    interval = Math.floor(seconds / 86400);
    
    if (interval > 1)
    {
        return interval + ' ' + mxResources.get('days');
    }
    
    interval = Math.floor(seconds / 3600);
    
    if (interval > 1)
    {
        return interval + ' ' + mxResources.get('hours');
    }
    
    interval = Math.floor(seconds / 60);
    
    if (interval > 1)
    {
        return interval + ' ' + mxResources.get('minutes');
    }
    
    if (interval == 1)
    {
        return interval + ' ' + mxResources.get('minute');
    }
    
    return null;
};

/**
 * Adds the listener for added and removed cells in the collab model and maps
 * them to the graph model.
 */
DriveRealtime.prototype.updateStatus = function()
{
	if (!this.saving)
	{
		// LATER: Check if realtime model contains last modified timestamp
		var mod = this.root.get('modifiedDate');
		
		if (mod != '')
		{
			// LATER: Write out modified date for more than 2 weeks ago
			var str = this.ui.timeSince(new Date(mod));
			
			if (str == null)
			{
				str = mxResources.get('lessThanAMinute');
			}
			
			this.ui.editor.setStatus(mxResources.get('lastChange', [str]) +
				(this.file.isEditable() ? '' : ' (' + mxResources.get('readOnly') + ')'));
		}
	}
};

/**
 * Currently the link back from map to page requires a loop.
 */
DriveRealtime.prototype.getPageIndexForMap = function(map)
{
	for (var i = 0; i < this.ui.pages.length; i++)
	{
		if (this.ui.pages[i].mapping.diagramMap == map)
		{
			return i;
		}
	}
	
	return null;
};

/**
 * Adds the listener for changes on the graph model and maps them to the collab
 * model as a single transaction.
 */
DriveRealtime.prototype.installPageSelectListener = function()
{
	// Adds a graph model listener to update the view
	this.pageChangeListener = mxUtils.bind(this, function(sender, evt)
	{
		var page = evt.getProperty('change').relatedPage;
		
		if (page.mapping == null)
		{
			page.mapping = new RealtimeMapping(this, this.rtModel.createMap(), page);
			page.mapping.init();
			
			if (this.file.isEditable())
			{
				page.mapping.diagramMap.set('name', page.getName());
			}
		}
	});
	
	this.ui.editor.addListener('beforePageChange', this.pageChangeListener);

	// Adds a graph model listener to update the view
	this.viewStateListener = mxUtils.bind(this, function(sender, evt)
	{
		var page = this.getCurrentPage();

		// Applies view state from realtime model without firing events
		if (page.viewState == null)
		{
			// Resets part of the view that is in view state but not in realtime model
			// via activate and not in setViewState (if state is null)
			var graph = this.ui.editor.graph;
			graph.view.scale = 1;
			graph.gridEnabled = !this.ui.editor.chromeless || urlParams['grid'] == '1';
			graph.gridSize = mxGraph.prototype.gridSize;
			graph.pageScale = mxGraph.prototype.pageScale;
			graph.pageVisible = this.ui.editor.graph.defaultPageVisible;
			graph.scrollbars = this.ui.editor.graph.defaultScrollbars;
			graph.graphHandler.guidesEnabled = true;
			graph.defaultParent = null;
			graph.setTooltips(true);
			graph.setConnectable(true);
			graph.setTooltips(true);
			
			// Actives from realtime without calling event listeners
			page.mapping.activate(true);
			this.ui.resetScrollbars();
		}
	});
	
	this.ui.editor.addListener('setViewState', this.viewStateListener);

	this.diagrams.addEventListener(gapi.drive.realtime.EventType.VALUES_ADDED, mxUtils.bind(this, function(evt)
	{
		if (!this.isLocalEvent(evt))
		{
			if (evt.movedFromList == null)
			{
				this.ignoreChange = true;
				
				for (var i = 0; i < evt.values.length; i++)
				{
					var page = new DiagramPage(document.createElement('diagram'));
					page.mapping = new RealtimeMapping(this, evt.values[i], page);
					page.setName(page.mapping.diagramMap.get('name') || mxResources.get('pageWithNumber',
						[this.ui.pages.length + 1]));
					this.ui.pages.splice(evt.index + i, 0, page);
					page.mapping.init();
				}

				this.ignoreChange = false;
				this.ui.updateTabContainer();
			}
			else if (evt.movedFromList == this.diagrams && evt.movedFromIndex != null)
			{
				this.ignoreChange = true;
			
				for (var i = 0; i < evt.values.length; i++)
				{
					var index = this.getPageIndexForMap(evt.values[i]);
					
					if (index != null)
					{
						this.ui.movePage(index + i, evt.index + i);
					}
				}
				
				this.ignoreChange = false;
				this.ui.updateTabContainer();
			}
		}
	}));
			
	this.diagrams.addEventListener(gapi.drive.realtime.EventType.VALUES_REMOVED, mxUtils.bind(this, function(evt)
	{
		if (!this.isLocalEvent(evt))
		{
			if (evt.movedToList == null)
			{
				this.ignoreChange = true;
				
				for (var i = 0; i < evt.values.length; i++)
				{
					var index = this.getPageIndexForMap(evt.values[i]);
					
					if (index != null)
					{
						this.ui.removePage(this.ui.pages[index]);
					}
				}
				
				this.ignoreChange = false;
			}
		}
	}));
};

/**
 * Returns a string representation of the given ops.
 */
DriveRealtime.prototype.processChange = function(change)
{
	//console.log('processChange: ' + this.dump(change));
	if (change instanceof RenamePage)
	{
		change.page.mapping.diagramMap.set('name', change.page.getName());
	}
	else if (change instanceof ChangePage)
	{
		if (change.previousIndex == null)
		{
			this.diagrams.removeValue(change.relatedPage.mapping.diagramMap);
		}
		else
		{
			this.diagrams.insert(change.previousIndex, change.relatedPage.mapping.diagramMap);
		}
	}
	else if (change instanceof MovePage)
	{
		this.diagrams.move(change.newIndex, change.oldIndex + ((change.newIndex < change.oldIndex) ? 1 : 0));
	}
	else if (change instanceof mxRootChange)
	{
		// Only process the root change that sets the current root
		// ie. ignore previous root changes
		if (change.root == this.model.root)
		{
			this.getCurrentPage().mapping.initRealtime();
		}
	}
	else if (change instanceof mxChildChange)
	{
		if (change.parent != change.previous || change.index != change.previousIndex)
		{
			var childRtCell = change.child.rtCell;
			
			if (childRtCell == null)
			{
				childRtCell = this.getCurrentPage().mapping.createRealtimeCell(change.child);
				this.getCurrentPage().mapping.saveRealtimeCell(childRtCell.cell);
			}

			var parentRtCell = (change.parent != null) ? change.parent.rtCell : null;
			
			if (change.previous != null)
			{
				var previousParentRtCell = change.previous.rtCell;
				
				if (previousParentRtCell != null)
				{
					previousParentRtCell.children.removeValue(childRtCell);
				}
			}

			if (parentRtCell != null)
			{
				parentRtCell.children.insert(Math.min(parentRtCell.children.length, change.index), childRtCell);
			}
			
			childRtCell.parent = parentRtCell;
		}
	}
	else if (change.cell != null && change.cell.id != null)
	{
		var rtCell = change.cell.rtCell;
		
		if (rtCell != null)
		{
			if (change instanceof mxTerminalChange)
			{
				var term = (change.terminal != null) ? change.terminal.rtCell : null;
				rtCell[(change.source) ? 'source' : 'target'] = term;
			}
			else if (change instanceof mxGeometryChange)
			{
				rtCell.geometry = (change.geometry != null) ? mxUtils.getXml(this.codec.encode(change.geometry)) : null;
			}
			else if (change instanceof mxStyleChange)
			{
				rtCell.style = change.style;
			}
			else if (change instanceof mxValueChange)
			{
				if (mxUtils.isNode(change.value))
				{
					rtCell.value = null;
					rtCell.xmlValue = mxUtils.getXml(change.value);
				}
				else
				{
					rtCell.xmlValue = null;
					rtCell.value = change.value;
				}
			}
			else if (change instanceof mxCollapseChange)
			{
				rtCell.collapsed = (change.collapsed) ? '1' : '0';
			}
			else if (change instanceof mxVisibleChange)
			{
				rtCell.visible = (change.visible) ? '1' : '0';
			}
		}
	}
};

/**
 * Adds the listener for changes on the graph model and maps them to the collab
 * model as a single transaction.
 */
DriveRealtime.prototype.setFileModified = function()
{
	this.root.set('modifiedDate', new Date().getTime());
	this.file.setModified(true);
	
	if (!this.saving)
	{
		this.ui.editor.setStatus(mxResources.get('saving') + '...');
		this.saving = true;
	}
};

/**
 * Adds the listener for changes on the graph model and maps them to the collab
 * model as a single transaction.
 */
DriveRealtime.prototype.installGraphModelListener = function()
{
	// Adds a graph model listener to update the view
	this.graphModelChangeListener = mxUtils.bind(this, function(sender, evt)
	{
		var edit = evt.getProperty('edit');
		
		if (!this.ignoreChange && this.file.isEditable() && !edit.ignoreEdit)
		{
			//console.log('startEdit');

			// TODO: Queuing for async token refresh and too many updates
			this.ui.drive.checkToken(mxUtils.bind(this, function()
			{
				this.rtModel.beginCompoundOperation();
				this.setFileModified();
				
				try
				{
					var changes = edit.changes;
					
					if (edit.undone)
					{
						for (var i = changes.length - 1; i >= 0; i--)
						{
							this.processChange(changes[i]);
						}
					}
					else
					{
						for (var i = 0; i < changes.length; i++)
						{
							this.processChange(changes[i]);
						}
					}
					
					this.rtModel.endCompoundOperation();
				}
				catch (e)
				{
					this.rtModel.endCompoundOperation();
					this.ui.handleError(e);
				}
				
				if (this.isAliveThread == null)
				{
					this.isAliveThread = window.setTimeout(mxUtils.bind(this, function()
					{
						this.ui.editor.setStatus('<div class="geStatusAlert geBlink" style="cursor:pointer;">' +
								mxResources.get('noResponse') + '</div>');
						
						this.isAliveThread = window.setTimeout(mxUtils.bind(this, function()
						{
							this.isAliveThread = null;
							this.timeoutError();
						}), this.realtimeHeartbeat);
					}), this.realtimeHeartbeat);
				}
			}));
			
			//console.log('endEdit');
		}
	});
	
	this.model.addListener(mxEvent.CHANGE, this.graphModelChangeListener);
};

/**
 * 
 */
DriveRealtime.prototype.sessionExpiredError = function() 
{
	// LATER: How to reload realtime document without refreshing the page
	this.ui.showError(mxResources.get('error'), mxResources.get('sessionExpired'), mxResources.get('refresh'), mxUtils.bind(this, function()
	{
		this.ui.spinner.spin(document.body, mxResources.get('connecting'));
		this.file.setModified(false);
		window.location.reload();
	}));
};

/**
 * 
 */
DriveRealtime.prototype.timeoutError = function() 
{
	// LATER: How to reload realtime document without refreshing the page
	this.ui.showError(mxResources.get('timeout'), mxResources.get('realtimeTimeout'), mxResources.get('discardChangesAndReconnect'), mxUtils.bind(this, function()
	{
		this.ui.spinner.spin(document.body, mxResources.get('connecting'));
		this.file.setModified(false);
		window.location.reload();
	}), null, mxResources.get('ignore'), mxUtils.bind(this, function()
	{
		this.ui.editor.setStatus('<div class="geStatusAlert geBlink" style="cursor:pointer;">' +
				mxResources.get('disconnected') + '</div>');	
		this.realtimeHeartbeat *= 2;
	}));
};

/**
 * 
 */
DriveRealtime.prototype.initializeChat = function() 
{
	this.chatHistory = this.rtModel.createList();
	this.root.set('chatHistory', this.chatHistory);
	//this.log('Chat history created');
};

/**
 * Adds a listener to the graph selection model and writes changes
 * in the RT selection map
 */
DriveRealtime.prototype.installSelectionModelListener = function()
{
	this.graphSelectionModelChangeListener = mxUtils.bind(this, function(sender, evt)
	{
		this.ui.drive.checkToken(mxUtils.bind(this, function()
		{
			if (this.file.isEditable() && !this.graph.isSelectionEmpty())
			{
				try
				{
					// LATER: Clear value if selection is empty. This is currently
					// disabled to avoid using up the quota in this case but the
					// better solution is to mark this "transient" (ie no history).
					var cells = this.graph.getSelectionCells();
					var selectedCellIds = '';
					
			    	for (var i = 0; i < cells.length; i++)
			    	{
			    		selectedCellIds += cells[i].id + ',';
			    	}
			    	
			    	this.getCurrentPage().mapping.selectionMap.set(this.userId, selectedCellIds);
				}
				catch (e)
				{
					this.ui.handleError(e);
				}
			}
		}));
	});
	
	this.graph.getSelectionModel().addListener(mxEvent.CHANGE, this.graphSelectionModelChangeListener);
};

/**
 * Connects the collaborator event listeners to the draw function.
 */
DriveRealtime.prototype.installCollaboratorListener = function()
{
	this.doc.addEventListener(gapi.drive.realtime.EventType.COLLABORATOR_JOINED, mxUtils.bind(this, this.updateCollaborators));
	this.doc.addEventListener(gapi.drive.realtime.EventType.COLLABORATOR_LEFT, mxUtils.bind(this, this.updateCollaborators));
};

/**
 * Draw function for the collaborator list.
 */
DriveRealtime.prototype.updateCollaborators = function()
{
	var n = this.doc.getCollaborators().length - 1;
	
	if (this.collaboratorsElement == null)
	{
		this.collaboratorsElement = document.createElement('a');
		this.collaboratorsElement.setAttribute('href', 'javascript:void(0);');
		this.collaboratorsElement.className = 'geItem';
		this.collaboratorsElement.style.position = 'absolute';
		this.collaboratorsElement.style.display = 'inline-block';
		this.collaboratorsElement.style.verticalAlign = 'bottom';
		this.collaboratorsElement.style.color = '#666';
		this.collaboratorsElement.style.top = '10px';
		this.collaboratorsElement.style.right = (uiTheme == 'atlas') ? '42px' : '68px';
		this.collaboratorsElement.style.padding = '2px';
		this.collaboratorsElement.style.fontSize = '8pt';
		this.collaboratorsElement.style.verticalAlign = 'middle';
		this.collaboratorsElement.style.backgroundPosition = '100% 60%';
		this.collaboratorsElement.style.backgroundRepeat = 'no-repeat';
		
		this.ui.toolbarContainer.appendChild(this.collaboratorsElement);
		
		mxEvent.addListener(this.collaboratorsElement, 'click', mxUtils.bind(this, function(evt)
		{
			if (this.collabPanel == null)
			{
				var div = document.createElement('div');
				div.className = 'geDialog';
				div.style.position = 'absolute';
				div.style.maxHeight = '400px';
				div.style.maxWidth = '300px';
				div.style.right = '38px';
				div.style.padding = '14px';
				div.style.paddingRight = '30px';

				this.collabPanel = div;
			}
			
			if (this.collabPanel.parentNode == null)
			{
				this.collabPanel.style.top = (this.collaboratorsElement.clientTop + this.collaboratorsElement.clientHeight + this.ui.menubarHeight + 8) + 'px';
				document.body.appendChild(this.collabPanel);
				this.collabPanel.innerHTML = '';
				
				var img = document.createElement('img');

				img.setAttribute('src', Dialog.prototype.closeImage);
				img.setAttribute('title', mxResources.get('close'));
				img.className = 'geDialogClose';
				img.style.top = '8px';
				img.style.right = '8px';
				
				mxEvent.addListener(img, 'click', mxUtils.bind(this, function()
				{
					if (this.collabPanel.parentNode != null)
					{
						this.collabPanel.parentNode.removeChild(this.collabPanel);
					}
				}));
				
				this.collabPanel.appendChild(img);
								
				if (this.doc.getCollaborators().length > 1)
				{
					for (var i = 0; i < this.doc.getCollaborators().length; i = i + 1)
					{
						var collaborator = this.doc.getCollaborators()[i];
						
						if (!collaborator.isMe)
						{
							var elt = document.createElement('div');
							elt.style.cursor = 'pointer';
							elt.style.whiteSpace = 'nowrap';
							
							var img = document.createElement('img');
							img.src = collaborator.photoUrl;
							img.style.backgroundColor = collaborator.color;
							img.style.paddingBottom = '8px';
							img.style.marginRight = '10px';
							img.style.marginTop = '2px';
							img.style.marginBottom = '2px';
							img.style.height = '25px';
							img.style.width = '25px';
							img.setAttribute('align', 'absmiddle');
							
							elt.appendChild(img);
							mxUtils.write(elt, collaborator.displayName);
							
							this.collabPanel.appendChild(elt);
							
							// Click on collaborator shows selection cells, scrolls to first cell
							mxEvent.addListener(elt, 'click', mxUtils.bind(this, function()
							{
								var value = this.getCurrentPage().mapping.selectionMap.get(collaborator.userId);
								
								if (value != null)
								{
									var cellIds = value.split(',');
									
									for (var i = 0; i < cellIds.length; i++)
									{
										var cell = this.model.getCell(cellIds[i]);
										this.highlight(cell, collaborator.sessionId);
										
										if (cell != null && i == 0)
										{
											this.graph.scrollCellToVisible(cell);
										}
									}
								}
							}));
						}
					}
				}
				else
				{
					mxUtils.write(this.collabPanel, mxResources.get('noOtherViewers'));
				}
			}
			else if (this.collabPanel.parentNode != null)
			{
				this.collabPanel.parentNode.removeChild(this.collabPanel);
			}
			
			mxEvent.consume(evt);
		}));
		
		mxEvent.addListener(document.body, 'click', mxUtils.bind(this, function(evt)
		{
			if (!mxEvent.isConsumed(evt) && this.collabPanel != null && this.collabPanel.parentNode != null)
			{
				this.collabPanel.parentNode.removeChild(this.collabPanel);
			}
		}));
	}
	
	var viewers = mxResources.get((n == 0) ? 'noOtherViewers' : ((n == 1) ? 'otherViewer' : 'otherViewers'));
	
	if (n > 0)
	{
		viewers = n + ' ' + viewers;
		this.collaboratorsElement.style.paddingRight = '16px';
		this.collaboratorsElement.style.backgroundImage =  'url(' + IMAGE_PATH + '/expanded.gif)';
		this.collaboratorsElement.style.cursor = 'pointer';
	}
	else
	{
		this.collaboratorsElement.style.paddingRight = '0px';
		this.collaboratorsElement.style.backgroundImage =  '';
		this.collaboratorsElement.style.cursor = 'default';
	}
	
	var html = '<div title="' + viewers + '" style="display:inline-block;white-space:nowrap;max-width:110px;overflow:hidden;text-overflow:ellipsis;">' + viewers + '</div>';
	
	var names = new Object();
	var count = 0;
	
	for (var i = 0; i < this.doc.getCollaborators().length && count < 6; i = i + 1)
	{
		var c = this.doc.getCollaborators()[i];
		
		if (!c.isMe && names[c.color] == null)
		{
			names[c.color] = c.displayName;
			count++;
		}
	}
	
	for (var color in names)
	{
		html += '<div title="' + mxUtils.htmlEntities(names[color]) + '" style="display:inline-block;background-color:' + color + ';width:13px;height:13px;margin-left:4px;margin-top:-1px;"></div>';
	}
	
	this.collaboratorsElement.innerHTML = html;
};

/**
 * Creates and returns a prefix for cell IDs.
 */
DriveRealtime.prototype.createPrefix = function()
{
	var collabs = this.doc.getCollaborators();
	
	for (var i = 0; i < collabs.length; i++)
	{
		if (collabs[i]['isMe'])
		{
			return collabs[i]['sessionId'];
		}
	}
	
	return '';
};

DriveRealtime.prototype.highlight = function(cell, sessionId)
{
	var state = this.graph.view.getState(cell);
	
	if (state != null)
	{
		var color = 'red'; // session not found
		
		for (var i = 0; i < this.doc.getCollaborators().length; i = i + 1)
		{
			var collaborator = this.doc.getCollaborators()[i];

			if (collaborator.sessionId == sessionId)
			{
				color = collaborator.color;
				
				break;
			}      
		}

		var sw = Math.max(5, mxUtils.getValue(state.style, mxConstants.STYLE_STROKEWIDTH, 1) + 4);
		var hl = new mxCellHighlight(this.graph, color, sw, false);
		hl.highlight(state);
		
		// Fades out the highlight after a delay
		window.setTimeout(function()
		{
			if (hl.shape != null)
			{
			 	mxUtils.setPrefixedStyle(hl.shape.node.style, 'transition', 'all 1200ms ease-in-out');
				hl.shape.node.style.opacity = 0;
			}
			
			window.setTimeout(function()
			{
				hl.destroy();
			}, 2000);
		}, 1000);
	}
};

/**
 * Writes out a string representing the current state of the document.
 */
DriveRealtime.prototype.dumpRoot = function()
{
	return this.dump(this.root);
};

/**
 * Creates a dump of the given map.
 */
DriveRealtime.prototype.dump = function(obj)
{
	var result = '';
	
	if (obj != null)
	{
		if (obj.constructor == mxCell)
		{
			return obj.id;
		}
		else if (obj.constructor == mxRootChange)
		{
			result += 'mxRootChange[root=' + this.dump(obj.root) + ']';
		}
		else if (obj.constructor == mxChildChange)
		{
			result += 'mxChildChange[parent=' + this.dump(obj.parent) +
				', child=' + this.dump(obj.child.id) +
				', index=' + obj.index + ']';
		}
		else if (obj.constructor == mxTerminalChange)
		{
			result += 'mxTerminalChange[cell=' + this.dump(obj.cell) +
				', terminal=' + this.dump(obj.terminal) +
				', source=' + obj.source + ']';
		}
		else if (obj.constructor == mxValueChange)
		{
			result += 'mxValueChange[cell=' + this.dump(obj.cell) + ', value=' + obj.value + ']';
		}
		else if (obj.constructor == mxGeometryChange)
		{
			result += 'mxGeometryChange[cell=' + this.dump(obj.cell) + ', geometry=' +
				((obj.cell.geometry != null) ? mxUtils.getXml(this.codec.encode(obj.cell.geometry)) : '[null]') + ']';
		}
		else if (obj.constructor == mxStyleChange)
		{
			result += 'mxStyleChange[cell=' + this.dump(obj.cell) + ', style=' + obj.style + ']';
		}
		else if (obj.constructor == mxVisibleChange)
		{
			result += 'mxVisibleChange[cell=' + this.dump(obj.cell) + ', visible=' + obj.visible + ']';
		}
		else if (obj.constructor == mxCollapseChange)
		{
			result += 'mxCollapseChange[cell=' + this.dump(obj.cell) + ', collapsed=' + obj.collapsed + ']';
		}
		else if (obj.constructor == mxRtCell)
		{
			result += '[id=' + obj.cellId + ',parent=' + ((obj.parent != null) ? obj.parent.cellId : '[null]');
			
			if (obj.children.length > 0)
			{
				result += ',\n' + obj.children.length + ' children=[' +
					this.dump(obj.children.get(0));
				
				for (var i = 1; i < obj.children.length; i++)
				{
					result += ',' + this.dump(obj.children.get(i));
				}
				
				result += ']';
			}
			
			result += ']\n';
		}
		else if (obj.keys != null)
		{
			var keys = obj.keys();
			result += '{\n';
			
			for (var i = 0; i < keys.length; i++)
			{
				result += keys[i] + '=' + this.dump(obj.get(keys[i])) + ';\n';
			}
			
			result += '}';
		}
		else if (obj.asArray != null)
		{
			var arr = obj.asArray();
			result += '[';
			
			for (var i = 0; i < arr.length; i++)
			{
				result += arr[i] + ';';
			}
			
			result += ']';
		}
		else
		{
			result = obj;
		}
	}
	else
	{
		result = 'null';
	}
	
	return result;
};

/**
 * Writes the given text to the log if <logging> is enabled.
 */
DriveRealtime.prototype.check = function()
{
	console.log('checking consistency');
	this.checkChildren(this.model.getRoot());
	console.log('checking consistency done');
};

/**
 * Writes the given text to the log if <logging> is enabled.
 */
DriveRealtime.prototype.checkChildren = function(cell)
{
	if (cell.rtCell == null)
	{
		console.log('no realtime cell', 'cell', cell.id);
	}
	else
	{
		if (cell.getTerminal(true) != null && (cell.rtCell.source == null ||
			cell.rtCell.source != cell.getTerminal(true).rtCell))
		{
			console.log('invalid source', 'edge', cell.id, 'source',
				cell.getTerminal(true).id, 'rtSource', cell.rtCell.source);
		}
		
		if (cell.getTerminal(false) != null && (cell.rtCell.target == null ||
			cell.rtCell.target != cell.getTerminal(false).rtCell))
		{
			console.log('invalid target', 'edge', cell.id, 'target',
				cell.getTerminal(false).id, 'rtTarget', cell.rtCell.target);
		}
		
		var childCount = this.model.getChildCount(cell);
		var children = cell.rtCell.children.asArray();
		
		if (childCount != cell.rtCell.children.length)
		{
			console.log('invalid child count', 'cell', cell.id, 'children',
				children.length, 'childCount', childCount);
		}
	
		for (var i = 0; i < cell.rtCell.children.length; i++)
		{
			var child = this.model.getChildAt(cell, i);
			
			if (child == null)
			{
				console.log('no child', 'index', i, 'child', cell.rtCell.children.get(i));
			}
			else if (cell.rtCell.children.get(i) != child.rtCell)
			{
				console.log('invalid child', 'index', i, 'child',
					cell.rtCell.children.get(i), 'graphChild', child);
			}
		}
	}
		
	for (var i = 0; i < childCount; i++)
	{
		var child = this.model.getChildAt(cell, i);
		this.checkChildren(child);
	}
};

/**
 * Writes the given text to the log if <logging> is enabled.
 */
DriveRealtime.prototype.log = function(message)
{
	if (this.logLevel > 1)
	{
		//mxLog.debug.apply(mxLog, arguments);
		//console.log(message);
	}
};

/**
 * Writes the given text to the log if <logging> is enabled.
 */
DriveRealtime.prototype.warn = function(message)
{
	if (this.logLevel > 0)
	{
		//mxLog.debug.apply(mxLog, arguments);
		//console.log(message);
	}
};

/**
 * Destroys the instance and removes all listeners.
 */
DriveRealtime.prototype.destroy = function(unloading)
{
	unloading = (unloading != null) ? unloading : false;
	
	if (this.pageFormatListener != null)
	{
		this.ui.removeListener(this.pageFormatListener);
		this.pageFormatListener = null;
	}
	
	if (this.pageScaleListener != null)
	{
		this.ui.removeListener(this.pageScaleListener);
		this.pageScaleListener = null;
	}

	if (this.backgroundColorListener != null)
	{
		this.ui.removeListener(this.backgroundColorListener);
		this.backgroundColorListener = null;
	}
	
	if (this.shadowVisibleListener != null)
	{
		this.graph.removeListener(this.shadowVisibleListener);
		this.shadowVisibleListener = null;
	}

	if (this.foldingEnabledListener != null)
	{
		this.ui.removeListener(this.foldingEnabledListener);
		this.foldingEnabledListener = null;
	}

	if (this.backgroundImageListener != null)
	{
		this.ui.removeListener(this.backgroundImageListener);
		this.backgroundImageListener = null;
	}

	if (this.mathEnabledListener != null)
	{
		this.ui.removeListener(this.mathEnabledListener);
		this.mathEnabledListener = null;
	}
	
	if (this.previousUndoListener != null)
	{
		this.ui.editor.undoListener = this.previousUndoListener;
		this.previousUndoListener = null;
	}

	if (this.graphSelectionModelChangeListener != null)
	{
		this.graph.selectionModel.removeListener(this.graphSelectionModelChangeListener);
		this.graphSelectionModelChangeListener = null;
	}
	
	if (this.disconnectListener != null)
	{
		this.ui.drive.removeListener(this.disconnectListener);
		this.disconnectListener = null;
	}
	
	if (this.autosaveChangeListener != null)
	{
		this.ui.editor.removeListener(this.autosaveChangeListener);
		this.autosaveChangeListener = null;
	}
	
	if (this.graphModelChangeListener != null)
	{
		this.model.removeListener(this.graphModelChangeListener);
		this.graphModelChangeListener = null;
	}

	if (this.viewStateListener != null)
	{
		this.ui.editor.removeListener(this.viewStateListener);
		this.viewStateListener = null;
	}
	
	if (this.collaboratorsElement != null)
	{
		this.collaboratorsElement.parentNode.removeChild(this.collaboratorsElement);
		this.collaboratorsElement = null;
	}
	
	if (this.updateStatusThread != null)
	{
		window.clearInterval(this.updateStatusThread);
		this.updateStatusThread = null;
	}
	
	this.ui.allowAnimation = true;

	try
	{
		// KNOWN: Cannot access g of null error in realtime
		// when called from window.onBeforeUnload handler
		if (!unloading && !this.doc.isClosed)
		{
			this.doc.close();
		}
	}
	catch (e)
	{
		// ignores possible document closed errors
	}
};