Subversion Repositories Applications.papyrus

if(!dojo._hasResource["dijit._editor.range"]){ //_hasResource checks added by build. Do not use _hasResource directly in your code.

dojo._hasResource["dijit._editor.range"] = true;

dojo.provide("dijit._editor.range");

dijit.range={};

dijit.range.getIndex=function(/*DomNode*/node, /*DomNode*/parent){

//	dojo.profile.start("dijit.range.getIndex");

	var ret=[], retR=[];

	var stop = parent;

	var onode = node;

	while(node != stop){

		var i = 0;

		var pnode = node.parentNode, n;

		while(n=pnode.childNodes[i++]){

			if(n===node){

				--i;

				break;

			}

		}

		if(i>=pnode.childNodes.length){

			dojo.debug("Error finding index of a node in dijit.range.getIndex");

		}

		ret.unshift(i);

		retR.unshift(i-pnode.childNodes.length);

		node = pnode;

	}

	//normalized() can not be called so often to prevent

	//invalidating selection/range, so we have to detect

	//here that any text nodes in a row

	if(ret.length>0 && onode.nodeType==3){

		var n = onode.previousSibling;

		while(n && n.nodeType==3){

			ret[ret.length-1]--;

			n = n.previousSibling;

		}

		n = onode.nextSibling;

		while(n && n.nodeType==3){

			retR[retR.length-1]++;

			n = n.nextSibling;

		}

	}

//	dojo.profile.end("dijit.range.getIndex");

	return {o: ret, r:retR};

}

dijit.range.getNode = function(/*Array*/index, /*DomNode*/parent){

	if(!dojo.isArray(index) || index.length==0){

		return parent;

	}

	var node = parent;

//	if(!node)debugger

	dojo.every(index, function(i){

		if(i>=0&&i< node.childNodes.length){

			node = node.childNodes[i];

		}else{

			node = null;

			console.debug('Error: can not find node with index',index,'under parent node',parent );

			return false; //terminate dojo.every

		}

		return true; //carry on the every loop

	});

	return node;

}

dijit.range.getCommonAncestor = function(n1,n2,root){

	var getAncestors = function(n,root){

		var as=[];

		while(n){

			as.unshift(n);

			if(n!=root && n.tagName!='BODY'){

				n = n.parentNode;

			}else{

				break;

			}

		}

		return as;

	};

	var n1as = getAncestors(n1,root);

	var n2as = getAncestors(n2,root);

	var m = Math.min(n1as.length,n2as.length);

	var com = n1as[0]; //at least, one element should be in the array: the root (BODY by default)

	for(var i=1;i<m;i++){

		if(n1as[i]===n2as[i]){

			com = n1as[i]

		}else{

			break;

		}

	}

	return com;

}

dijit.range.getAncestor = function(/*DomNode*/node, /*RegEx?*/regex, /*DomNode?*/root){

	root = root || node.ownerDocument.body;

	while(node && node !== root){

		var name = node.nodeName.toUpperCase() ;

		if(regex.test(name)){

			return node;

		}

		node = node.parentNode;

	}

	return null;

}

dijit.range.BlockTagNames = /^(?:P|DIV|H1|H2|H3|H4|H5|H6|ADDRESS|PRE|OL|UL|LI|DT|DE)$/;

dijit.range.getBlockAncestor = function(/*DomNode*/node, /*RegEx?*/regex, /*DomNode?*/root){

	root = root || node.ownerDocument.body;

	regex = regex || dijit.range.BlockTagNames;

	var block=null, blockContainer;

	while(node && node !== root){

		var name = node.nodeName.toUpperCase() ;

		if(!block && regex.test(name)){

			block = node;

		}

		if(!blockContainer && (/^(?:BODY|TD|TH|CAPTION)$/).test(name)){

			blockContainer = node;

		}

		node = node.parentNode;

	}

	return {blockNode:block, blockContainer:blockContainer || node.ownerDocument.body};

}

dijit.range.atBeginningOfContainer = function(/*DomNode*/container, /*DomNode*/node, /*Int*/offset){

	var atBeginning = false;

	var offsetAtBeginning = (offset == 0);

	if(!offsetAtBeginning && node.nodeType==3){ //if this is a text node, check whether the left part is all space

		if(dojo.trim(node.nodeValue.substr(0,offset))==0){

			offsetAtBeginning = true;

		}

	}

	if(offsetAtBeginning){

		var cnode = node;

		atBeginning = true;

		while(cnode && cnode !== container){

			if(cnode.previousSibling){

				atBeginning = false;

				break;

			}

			cnode = cnode.parentNode;

		}

	}

	return atBeginning;

}

dijit.range.atEndOfContainer = function(/*DomNode*/container, /*DomNode*/node, /*Int*/offset){

	var atEnd = false;

	var offsetAtEnd = (offset == (node.length || node.childNodes.length));

	if(!offsetAtEnd && node.nodeType==3){ //if this is a text node, check whether the right part is all space

		if(dojo.trim(node.nodeValue.substr(offset))==0){

			offsetAtEnd = true;

		}

	}

	if(offsetAtEnd){

		var cnode = node;

		atEnd = true;

		while(cnode && cnode !== container){

			if(cnode.nextSibling){

				atEnd = false;

				break;

			}

			cnode = cnode.parentNode;

		}

	}

	return atEnd;

}

dijit.range.adjacentNoneTextNode=function(startnode, next){

	var node = startnode;

	var len = (0-startnode.length) || 0;

	var prop = next?'nextSibling':'previousSibling';

	while(node){

		if(node.nodeType!=3){

			break;

		}

		len += node.length

		node = node[prop];

	}

	return [node,len];

}

dijit.range._w3c = Boolean(window['getSelection']);

dijit.range.create = function(){

	if(dijit.range._w3c){

		return document.createRange();

	}else{//IE

		return new dijit.range.W3CRange;

	}

}

dijit.range.getSelection = function(win, /*Boolean?*/ignoreUpdate){

	if(dijit.range._w3c){

		return win.getSelection();

	}else{//IE

		var id=win.__W3CRange;

		if(!id || !dijit.range.ie.cachedSelection[id]){

			var s = new dijit.range.ie.selection(win);

			//use win as the key in an object is not reliable, which

			//can leads to quite odd behaviors. thus we generate a

			//string and use it as a key in the cache

			id=(new Date).getTime();

			while(id in dijit.range.ie.cachedSelection){

				id=id+1;

			}

			id=String(id);

			dijit.range.ie.cachedSelection[id] = s;

		}else{

			var s = dijit.range.ie.cachedSelection[id];

		}

		if(!ignoreUpdate){

			s._getCurrentSelection();

		}

		return s;

	}

}

if(!dijit.range._w3c){

	dijit.range.ie={

		cachedSelection: {},

		selection: function(win){

			this._ranges = [];

			this.addRange = function(r, /*boolean*/internal){

				this._ranges.push(r);

				if(!internal){

					r._select();

				}

				this.rangeCount = this._ranges.length;

			};

			this.removeAllRanges = function(){

				//don't detach, the range may be used later

//				for(var i=0;i<this._ranges.length;i++){

//					this._ranges[i].detach();

//				}

				this._ranges = [];

				this.rangeCount = 0;

			};

			var _initCurrentRange = function(){

				var r = win.document.selection.createRange();

				var type=win.document.selection.type.toUpperCase();

				if(type == "CONTROL"){

					//TODO: multiple range selection(?)

					return new dijit.range.W3CRange(dijit.range.ie.decomposeControlRange(r));

				}else{

					return new dijit.range.W3CRange(dijit.range.ie.decomposeTextRange(r));

				}

			};

			this.getRangeAt = function(i){

				return this._ranges[i];

			};

			this._getCurrentSelection = function(){

				this.removeAllRanges();

				var r=_initCurrentRange();

				if(r){

					this.addRange(r, true);

				}

			};

		},

		decomposeControlRange: function(range){

			var firstnode = range.item(0), lastnode = range.item(range.length-1)

			var startContainer = firstnode.parentNode, endContainer = lastnode.parentNode;

			var startOffset = dijit.range.getIndex(firstnode, startContainer).o;

			var endOffset = dijit.range.getIndex(lastnode, endContainer).o+1;

			return [[startContainer, startOffset],[endContainer, endOffset]];

		},

		getEndPoint: function(range, end){

			var atmrange = range.duplicate();

			atmrange.collapse(!end);

			var cmpstr = 'EndTo' + (end?'End':'Start');

			var parentNode = atmrange.parentElement();

			var startnode, startOffset, lastNode;

			if(parentNode.childNodes.length>0){

				dojo.every(parentNode.childNodes, function(node,i){

					var calOffset;

					if(node.nodeType != 3){

						atmrange.moveToElementText(node);

						if(atmrange.compareEndPoints(cmpstr,range) > 0){

							startnode = node.previousSibling;

							if(lastNode && lastNode.nodeType == 3){

								//where share we put the start? in the text node or after?

								startnode = lastNode;

								calOffset = true;

							}else{

								startnode = parentNode;

								startOffset = i;

								return false;

							}

						}else{

							if(i==parentNode.childNodes.length-1){

								startnode = parentNode;

								startOffset = parentNode.childNodes.length;

								return false;

							}

						}

					}else{

						if(i==parentNode.childNodes.length-1){//at the end of this node

							startnode = node;

							calOffset = true;

						}

					}

		//			try{

						if(calOffset && startnode){

							var prevnode = dijit.range.adjacentNoneTextNode(startnode)[0];

							if(prevnode){

								startnode = prevnode.nextSibling;

							}else{

								startnode = parentNode.firstChild; //firstChild must be a text node

							}

							var prevnodeobj = dijit.range.adjacentNoneTextNode(startnode);

							prevnode = prevnodeobj[0];

							var lenoffset = prevnodeobj[1];

							if(prevnode){

								atmrange.moveToElementText(prevnode);

								atmrange.collapse(false);

							}else{

								atmrange.moveToElementText(parentNode);

							}

							atmrange.setEndPoint(cmpstr, range);

							startOffset = atmrange.text.length-lenoffset;

							return false;

						}

		//			}catch(e){ debugger }

					lastNode = node;

					return true;

				});

			}else{

				startnode = parentNode;

				startOffset = 0;

			}

			//if at the end of startnode and we are dealing with start container, then

			//move the startnode to nextSibling if it is a text node

			//TODO: do this for end container?

			if(!end && startnode.nodeType!=3 && startOffset == startnode.childNodes.length){

				if(startnode.nextSibling && startnode.nextSibling.nodeType==3){

					startnode = startnode.nextSibling;

					startOffset = 0;

				}

			}

			return [startnode, startOffset];

		},

		setEndPoint: function(range, container, offset){

			//text node

			var atmrange = range.duplicate();

			if(container.nodeType!=3){ //normal node

				atmrange.moveToElementText(container);

				atmrange.collapse(true);

				if(offset == container.childNodes.length){

					if(offset > 0){

						//a simple atmrange.collapse(false); won't work here:

						//although moveToElementText(node) is supposed to encompass the content of the node,

						//but when collapse to end, it is in fact after the ending tag of node (collapse to start

						//is after the begining tag of node as expected)

						var node = container.lastChild;

						var len = 0;

						while(node && node.nodeType == 3){

							len += node.length;

							container = node; //pass through

							node = node.previousSibling;

						}

						if(node){

							atmrange.moveToElementText(node);

						}

						atmrange.collapse(false);

						offset = len; //pass through

					}else{ //no childNodes

						atmrange.moveToElementText(container);

						atmrange.collapse(true);

					}

				}else{

					if(offset > 0){

						var node = container.childNodes[offset-1];

						if(node.nodeType==3){

							container = node;

							offset = node.length;

							//pass through

						}else{

							atmrange.moveToElementText(node);

							atmrange.collapse(false);

						}

					}

				}

			}

			if(container.nodeType==3){

				var prevnodeobj = dijit.range.adjacentNoneTextNode(container);

				var prevnode = prevnodeobj[0], len = prevnodeobj[1];

				if(prevnode){

					atmrange.moveToElementText(prevnode);

					atmrange.collapse(false);

					//if contentEditable is not inherit, the above collapse won't make the end point

					//in the correctly position: it always has a -1 offset, so compensate it

					if(prevnode.contentEditable!='inherit'){

						len++;

					}

				}else{

					atmrange.moveToElementText(container.parentNode);

					atmrange.collapse(true);

				}

				offset += len;

				if(offset>0){

					if(atmrange.moveEnd('character',offset) != offset){

						alert('Error when moving!');

					}

					atmrange.collapse(false);

				}

			}

			return atmrange;

		},

		decomposeTextRange: function(range){

			var tmpary = dijit.range.ie.getEndPoint(range);

			var startContainter = tmpary[0], startOffset = tmpary[1];

			var endContainter = tmpary[0], endOffset = tmpary[1];

			if(range.htmlText.length){

				if(range.htmlText == range.text){ //in the same text node

					endOffset = startOffset+range.text.length;

				}else{

					tmpary = dijit.range.ie.getEndPoint(range,true);

					endContainter = tmpary[0], endOffset = tmpary[1];

				}

			}

			return [[startContainter, startOffset],[endContainter, endOffset], range.parentElement()];

		},

		setRange: function(range, startContainter,

			startOffset, endContainter, endOffset, check){

			var startrange = dijit.range.ie.setEndPoint(range, startContainter, startOffset);

			range.setEndPoint('StartToStart', startrange);

			if(!this.collapsed){

				var endrange = dijit.range.ie.setEndPoint(range, endContainter, endOffset);

				range.setEndPoint('EndToEnd', endrange);

			}

			return range;

		}

	}

dojo.declare("dijit.range.W3CRange",null, {

	constructor: function(){

		if(arguments.length>0){

			this.setStart(arguments[0][0][0],arguments[0][0][1]);

			this.setEnd(arguments[0][1][0],arguments[0][1][1],arguments[0][2]);

		}else{

			this.commonAncestorContainer = null;

			this.startContainer = null;

			this.startOffset = 0;

			this.endContainer = null;

			this.endOffset = 0;

			this.collapsed = true;

		}

	},

	_simpleSetEndPoint: function(node, range, end){

		var r = (this._body||node.ownerDocument.body).createTextRange();

		if(node.nodeType!=1){

			r.moveToElementText(node.parentNode);

		}else{

			r.moveToElementText(node);

		}

		r.collapse(true);

		range.setEndPoint(end?'EndToEnd':'StartToStart',r);

	},

	_updateInternal: function(__internal_common){

		if(this.startContainer !== this.endContainer){

			if(!__internal_common){

				var r = (this._body||this.startContainer.ownerDocument.body).createTextRange();

				this._simpleSetEndPoint(this.startContainer,r);

				this._simpleSetEndPoint(this.endContainer,r,true);

				__internal_common = r.parentElement();

			}

			this.commonAncestorContainer = dijit.range.getCommonAncestor(this.startContainer, this.endContainer, __internal_common);

		}else{

			this.commonAncestorContainer = this.startContainer;

		}

		this.collapsed = (this.startContainer === this.endContainer) && (this.startOffset == this.endOffset);

	},

	setStart: function(node, offset, __internal_common){

		if(this.startContainer === node && this.startOffset == offset){

			return;

		}

		delete this._cachedBookmark;

		this.startContainer = node;

		this.startOffset = offset;

		if(!this.endContainer){

			this.setEnd(node, offset, __internal_common);

		}else{

			this._updateInternal(__internal_common);

		}

	},

	setEnd: function(node, offset, __internal_common){

		if(this.endContainer === node && this.endOffset == offset){

			return;

		}

		delete this._cachedBookmark;

		this.endContainer = node;

		this.endOffset = offset;

		if(!this.startContainer){

			this.setStart(node, offset, __internal_common);

		}else{

			this._updateInternal(__internal_common);

		}

	},

	setStartAfter: function(node, offset){

		this._setPoint('setStart', node, offset, 1);

	},

	setStartBefore: function(node, offset){

		this._setPoint('setStart', node, offset, 0);

	},

	setEndAfter: function(node, offset){

		this._setPoint('setEnd', node, offset, 1);

	},

	setEndBefore: function(node, offset){

		this._setPoint('setEnd', node, offset, 0);

	},

	_setPoint: function(what, node, offset, ext){

		var index = dijit.range.getIndex(node, node.parentNode).o;

		this[what](node.parentNode, index.pop()+ext);

	},

	_getIERange: function(){

		var r=(this._body||this.endContainer.ownerDocument.body).createTextRange();

		dijit.range.ie.setRange(r, this.startContainer, this.startOffset, this.endContainer, this.endOffset);

		return r;

	},

	getBookmark: function(body){

		this._getIERange();

		return this._cachedBookmark;

	},

	_select: function(){

		var r = this._getIERange();

		r.select();

	},

	deleteContents: function(){

		var r = this._getIERange();

		r.pasteHTML('');

		this.endContainer = this.startContainer;

		this.endOffset = this.startOffset;

		this.collapsed = true;

	},

	cloneRange: function(){

		var r = new dijit.range.W3CRange([[this.startContainer,this.startOffset],

			[this.endContainer,this.endOffset]]);

		r._body = this._body;

		return r;

	},

	detach: function(){

		this._body = null;

		this.commonAncestorContainer = null;

		this.startContainer = null;

		this.startOffset = 0;

		this.endContainer = null;

		this.endOffset = 0;

		this.collapsed = true;

}

});

} //if(!dijit.range._w3c)

}