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)

}