| New file |
|---|
| 0,0 → 1,566 |
|---|
| 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) |
| |
| } |