开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多国语言处理 > 词法分析 > 查看源码
RangeImpl.cpp
资源名称：xerces-c-src_2_3_0.zip　[点击查看]
上传用户：zhuqijet
上传日期：2013-06-25
资源大小：10074k
文件大小：50k
源码类别：

词法分析

开发平台：

Visual C++

RangeImpl.cpp：源码内容
  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 1999-2002 The Apache Software Foundation.  All rights
  5.  * reserved.
  6.  *
  7.  * Redistribution and use in source and binary forms, with or without
  8.  * modification, are permitted provided that the following conditions
  9.  * are met:
  10.  *
  11.  * 1. Redistributions of source code must retain the above copyright
  12.  *    notice, this list of conditions and the following disclaimer.
  13.  *
  14.  * 2. Redistributions in binary form must reproduce the above copyright
  15.  *    notice, this list of conditions and the following disclaimer in
  16.  *    the documentation and/or other materials provided with the
  17.  *    distribution.
  18.  *
  19.  * 3. The end-user documentation included with the redistribution,
  20.  *    if any, must include the following acknowledgment:
  21.  *       "This product includes software developed by the
  22.  *        Apache Software Foundation (http://www.apache.org/)."
  23.  *    Alternately, this acknowledgment may appear in the software itself,
  24.  *    if and wherever such third-party acknowledgments normally appear.
  25.  *
  26.  * 4. The names "Xerces" and "Apache Software Foundation" must
  27.  *    not be used to endorse or promote products derived from this
  28.  *    software without prior written permission. For written
  29.  *    permission, please contact apache@apache.org.
  30.  *
  31.  * 5. Products derived from this software may not be called "Apache",
  32.  *    nor may "Apache" appear in their name, without prior written
  33.  *    permission of the Apache Software Foundation.
  34.  *
  35.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  36.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  37.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  38.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  39.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  41.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  42.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  43.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  44.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  45.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  46.  * SUCH DAMAGE.
  47.  * ====================================================================
  48.  *
  49.  * This software consists of voluntary contributions made by many
  50.  * individuals on behalf of the Apache Software Foundation, and was
  51.  * originally based on software copyright (c) 1999, International
  52.  * Business Machines, Inc., http://www.ibm.com .  For more information
  53.  * on the Apache Software Foundation, please see
  54.  * <http://www.apache.org/>.
  55.  */
  57. /*
  58.  * $Id: RangeImpl.cpp,v 1.4 2003/05/18 14:02:03 knoaman Exp $
  59.  */
  61. #include <xercesc/util/RefVectorOf.hpp>
  62. #include "NodeImpl.hpp"
  63. #include "RangeImpl.hpp"
  64. #include "TextImpl.hpp"
  65. #include "DocumentImpl.hpp"
  66. #include "DOM_DOMException.hpp"
  67. #include "DOM_Document.hpp"
  68. #include "DocumentFragmentImpl.hpp"
  69. #include "DOM_Document.hpp"
  70. #include "DOM_RangeException.hpp"
  71. #include "DOM_DOMException.hpp"
  72. #include "DOM_Text.hpp"
  74. XERCES_CPP_NAMESPACE_BEGIN
  77. //---------------------
  78. // C'tor and D'tor
  79. //---------------------
  81. RangeImpl::RangeImpl(DOM_Document doc)
  83.     :   fDocument(doc),
  84.         fStartContainer(doc),
  85.         fStartOffset(0),
  86.         fEndContainer(doc),
  87.         fEndOffset(0),
  88.         fDetached(false),
  89.         fCollapsed(true),
  90.         fRemoveChild(0)
  91. {
  92. }
  94. RangeImpl::RangeImpl(const RangeImpl& other)
  95. {
  96.     fDocument = other.fDocument;
  97.     fStartContainer = other.fStartContainer;
  98.     fStartOffset = other.fStartOffset;
  99.     fEndContainer = other.fEndContainer;
  100.     fEndOffset = other.fEndOffset;
  101.     fDetached = other.fDetached;
  102.     fCollapsed = other.fCollapsed;
  103.     fRemoveChild = other.fRemoveChild;
  104. }
  106. RangeImpl::~RangeImpl()
  107. {
  108. }
  110. void RangeImpl::unreferenced()
  111. {
  112.     if (((DocumentImpl*)fDocument.fImpl)->ranges != 0L) {
  113.         int sz = ((DocumentImpl*)fDocument.fImpl)->ranges->size();
  114.         for (int i=0; i< sz; i++) {
  115.             if (((DocumentImpl*)fDocument.fImpl)->ranges->elementAt(i) == this) {
  116.                 ((DocumentImpl*)fDocument.fImpl)->ranges->removeElementAt(i);
  117.                 break;
  118.             }
  119.         }
  120.     }
  121. //    delete this;
  122.     RangeImpl* ptr = this;
  123.     delete ptr;
  124. };
  127. //-------------------------------
  128. // Public getter functions
  129. //-------------------------------
  132. DOM_Node RangeImpl::getStartContainer() const
  133. {
  134.     return fStartContainer;
  135. }
  137. unsigned int RangeImpl::getStartOffset() const
  138. {
  139.     return fStartOffset;
  140. }
  142. DOM_Node RangeImpl::getEndContainer() const
  143. {
  144.     return fEndContainer;
  145. }
  147. unsigned int RangeImpl::getEndOffset() const
  148. {
  149.     return fEndOffset;
  150. }
  154. bool RangeImpl::getCollapsed() const
  155. {
  156.     if (fDetached)
  157.     {
  158.         throw DOM_DOMException(
  159.             DOM_DOMException::INVALID_STATE_ERR, null);
  160.     }
  162.     return ((fStartContainer == fEndContainer)
  163.              && (fStartOffset == fEndOffset));
  164. }
  166. //-------------------------------
  167. // Public getter functions
  168. //-------------------------------
  170. void RangeImpl::setStartContainer(const DOM_Node& node)
  171. {
  172.     if (fDetached)
  173.     {
  174.         throw DOM_DOMException(
  175.             DOM_DOMException::INVALID_STATE_ERR, null);
  176.     }
  178.     fStartContainer = node;
  179. }
  181. void RangeImpl::setStartOffset(unsigned int offset)
  182. {
  183.     if (fDetached)
  184.     {
  185.         throw DOM_DOMException(
  186.             DOM_DOMException::INVALID_STATE_ERR, null);
  187.     }
  189.     fStartOffset = offset;
  190. }
  192. void RangeImpl::setEndContainer(const DOM_Node& node)
  193. {
  194.     if (fDetached)
  195.     {
  196.         throw DOM_DOMException(
  197.             DOM_DOMException::INVALID_STATE_ERR, null);
  198.     }
  200.     fEndContainer = node;
  202. }
  204. void RangeImpl::setEndOffset(unsigned int offset)
  205. {
  206.     if (fDetached)
  207.     {
  208.         throw DOM_DOMException(
  209.             DOM_DOMException::INVALID_STATE_ERR, null);
  210.     }
  212.     fEndOffset = offset;
  213. }
  215. void RangeImpl::setStart(const DOM_Node& refNode, unsigned int offset)
  216. {
  217.     validateNode(refNode);
  218.     checkIndex(refNode, offset);
  220.     fStartContainer = refNode;
  221.     fStartOffset    = offset;
  223.     if ((fDocument != refNode.getOwnerDocument() )
  224.         && (refNode.getOwnerDocument().fImpl != 0) )
  225.     {
  226.         fDocument = refNode.getOwnerDocument();
  227.         collapse(true);
  228.     }
  230.     //compare the start and end boundary point
  231.     //collapse if start point is after the end point
  232.     if(compareBoundaryPoints(DOM_Range::END_TO_START, this) == 1)
  233.         collapse(true); //collapse the range positions to start
  234.     else
  235.         fCollapsed = false;
  236. }
  238. void RangeImpl::setEnd(const DOM_Node& refNode, unsigned int offset)
  239. {
  240.     validateNode(refNode);
  241.     checkIndex(refNode, offset);
  243.     fEndContainer   = refNode;
  244.     fEndOffset      = offset;
  246.     if ((fDocument != refNode.getOwnerDocument() )
  247.         && (refNode.getOwnerDocument().fImpl != 0) )
  248.     {
  249.         fDocument = refNode.getOwnerDocument();
  250.         collapse(false);
  251.     }
  253.     //compare the start and end boundary point
  254.     //collapse if start point is after the end point
  255.     if(compareBoundaryPoints(DOM_Range::END_TO_START, this) == 1)
  256.         collapse(false); //collapse the range positions to end
  257.     else
  258.         fCollapsed = false;
  259. }
  261. void RangeImpl::setStartBefore(const DOM_Node& refNode)
  262. {
  263.     if( fDetached) {
  264.         throw DOM_DOMException(
  265.             DOM_DOMException::INVALID_STATE_ERR, null);
  266.     }
  267.     if ( !hasLegalRootContainer(refNode) || !isLegalContainedNode(refNode)) {
  268.         throw DOM_RangeException(
  269.             DOM_RangeException::INVALID_NODE_TYPE_ERR, null);
  270.     }
  272.     fStartContainer = refNode.getParentNode();
  273.    unsigned int i = 0;
  274.     for (DOM_Node n = refNode; n!=null; n = n.getPreviousSibling()) {
  275.         i++;
  276.     }
  277.     if (i == 0)
  278.         fStartOffset = 0;
  279.     else
  280.         fStartOffset = i-1;
  282.     if ((fDocument != refNode.getOwnerDocument())
  283.         && (refNode.getOwnerDocument().fImpl != 0) )
  284.     {
  285.         fDocument = refNode.getOwnerDocument();
  286.         collapse(true);
  287.     }
  289.     //compare the start and end boundary point
  290.     //collapse if start point is after the end point
  291.     if(compareBoundaryPoints(DOM_Range::END_TO_START, this) == 1)
  292.         collapse(true); //collapse the range positions to start
  293.     else
  294.         fCollapsed = false;
  295. }
  297. void RangeImpl::setStartAfter(const DOM_Node& refNode)
  298. {
  299.     if( fDetached) {
  300.         throw DOM_DOMException(
  301.             DOM_DOMException::INVALID_STATE_ERR, null);
  302.     }
  303.     if ( !hasLegalRootContainer(refNode) || !isLegalContainedNode(refNode)) {
  304.         throw DOM_RangeException(
  305.             DOM_RangeException::INVALID_NODE_TYPE_ERR, null);
  306.     }
  308.     fStartContainer = refNode.getParentNode();
  309.     unsigned int i = 0;
  310.     for (DOM_Node n = refNode; n!=null; n = n.getPreviousSibling()) {
  311.         i++;
  312.     }
  314.     fStartOffset = i;
  316.     if ((fDocument != refNode.getOwnerDocument() )
  317.         && (refNode.getOwnerDocument().fImpl != 0) )
  318.     {
  319.         fDocument = refNode.getOwnerDocument();
  320.         collapse(true);
  321.     }
  323.     //compare the start and end boundary point
  324.     //collapse if start point is after the end point
  325.     if(compareBoundaryPoints(DOM_Range::END_TO_START, this) == 1)
  326.         collapse(true); //collapse the range positions to start
  327.     else
  328.         fCollapsed = false;
  329. }
  331. void RangeImpl::setEndBefore(const DOM_Node& refNode)
  332. {
  333.     if( fDetached) {
  334.         throw DOM_DOMException(
  335.             DOM_DOMException::INVALID_STATE_ERR, null);
  336.     }
  337.     if ( !hasLegalRootContainer(refNode) || !isLegalContainedNode(refNode)) {
  338.         throw DOM_RangeException(
  339.             DOM_RangeException::INVALID_NODE_TYPE_ERR, null);
  340.     }
  342.     fEndContainer = refNode.getParentNode();
  343.     unsigned int i = 0;
  344.     for (DOM_Node n = refNode; n!=null; n = n.getPreviousSibling(), i++) ;
  346.     if (i< 1)
  347.         fEndOffset = 0;
  348.     else
  349.         fEndOffset = i-1;
  351.     if ((fDocument != refNode.getOwnerDocument() )
  352.         && (refNode.getOwnerDocument().fImpl != 0) )
  353.     {
  354.         fDocument = refNode.getOwnerDocument();
  355.         collapse(true);
  356.     }
  358.     //compare the start and end boundary point
  359.     //collapse if start point is after the end point
  360.     if(compareBoundaryPoints(DOM_Range::END_TO_START, this) == 1)
  361.         collapse(false); //collapse the range positions to end
  362.     else
  363.         fCollapsed = false;
  364. }
  366. void RangeImpl::setEndAfter(const DOM_Node& refNode)
  367. {
  368.     if( fDetached) {
  369.         throw DOM_DOMException(
  370.             DOM_DOMException::INVALID_STATE_ERR, null);
  371.     }
  372.     if ( !hasLegalRootContainer(refNode) || !isLegalContainedNode(refNode)) {
  373.         throw DOM_RangeException(
  374.             DOM_RangeException::INVALID_NODE_TYPE_ERR, null);
  375.     }
  377.     fEndContainer = refNode.getParentNode();
  378.     unsigned int i = 0;
  379.     for (DOM_Node n = refNode; n!=null; n = n.getPreviousSibling(), i++) ;
  381.     if (i ==0)
  382.         fEndOffset = 0;
  383.     else
  384.         fEndOffset = i;
  386.     if ((fDocument != refNode.getOwnerDocument() )
  387.         && (refNode.getOwnerDocument().fImpl != 0) )
  388.     {
  389.         fDocument = refNode.getOwnerDocument();
  390.         collapse(true);
  391.     }
  393.     //compare the start and end boundary point
  394.     //collapse if start point is after the end point
  395.     if(compareBoundaryPoints(DOM_Range::END_TO_START, this) == 1)
  396.         collapse(false); //collapse the range positions to end
  397.     else
  398.         fCollapsed = false;
  399. }
  400. //-------------------------------
  401. // Public Misc. functions
  402. //-------------------------------
  403. void RangeImpl::detach()
  404. {
  405.     if( fDetached) {
  406.         throw DOM_DOMException(
  407.             DOM_DOMException::INVALID_STATE_ERR, null);
  408.     }
  410.     fDetached = true;
  412.     //nullify nodes
  413.     fStartContainer = 0;
  414.     fStartOffset    = 0;
  415.     fEndContainer   = 0;
  416.     fEndOffset      = 0;
  417.     fCollapsed      = true;
  419.     fRemoveChild    = 0;
  420. }
  422. void RangeImpl::collapse(bool toStart)
  423. {
  424.     if( fDetached) {
  425.         throw DOM_DOMException(
  426.             DOM_DOMException::INVALID_STATE_ERR, null);
  427.     }
  429.     if (toStart) {
  430.         fEndContainer = fStartContainer;
  431.         fEndOffset = fStartOffset;
  432.     } else {
  433.         fStartContainer = fEndContainer;
  434.         fStartOffset = fEndOffset;
  435.     }
  436.     fCollapsed = true;
  437. }
  439. void RangeImpl::selectNode(const DOM_Node& refNode)
  440. {
  441.     validateNode(refNode);
  442.     if ( !isLegalContainedNode(refNode)) {
  443.         throw DOM_RangeException(
  444.             DOM_RangeException::INVALID_NODE_TYPE_ERR, null);
  445.     }
  446.     //First check for the text type node
  447.     if (refNode.getNodeType() ==  DOM_Node::TEXT_NODE)
  448.     {
  449.         //The node itself is the container.
  450.         fStartContainer = refNode;
  451.         fEndContainer   = refNode;
  453.         //Select all the contents of the node
  454.         fStartOffset = 0;
  455.         fEndOffset = ((DOM_Text &)refNode).getLength();
  456.         return;
  457.     }
  459.     DOM_Node parent = refNode.getParentNode();
  460.     if (parent != null ) // REVIST: what to do if it IS null?
  461.     {
  462.         fStartContainer = parent;
  463.         fEndContainer = parent;
  465.         unsigned int i = 0;
  466.         for (DOM_Node n = parent.getFirstChild(); n!=null, n!=refNode; n = n.getNextSibling()) {
  467.             i++;
  468.         }
  470.         fStartOffset = i;
  471.         fEndOffset = fStartOffset+1;
  472.     }
  473. }
  475. void RangeImpl::selectNodeContents(const DOM_Node& node)
  476. {
  477.     validateNode(node);
  479.     fStartContainer = node;
  480.     fEndContainer = node;
  482.     fStartOffset = 0;
  483.     if (node.getNodeType() == DOM_Node::TEXT_NODE ) {
  484.         fEndOffset = ((DOM_Text &)node).getLength();
  485.         return;
  486.     }
  488.     DOM_Node first = node.getFirstChild();
  489.     if (first == null) {
  490.         fEndOffset = 0;
  491.         return;
  492.     }
  493.     unsigned int i = 0;
  494.     for (DOM_Node n = first; n!=null; n = n.getNextSibling()) {
  495.         i++;
  496.     }
  497.     fEndOffset = i;
  498. }
  500. void RangeImpl::surroundContents(DOM_Node& newParent)
  501. {
  502.     if (newParent==null) return;
  504.     //check for elimination criteria
  505.     if( fDetached) {
  506.         throw DOM_DOMException(
  507.             DOM_DOMException::INVALID_STATE_ERR, null);
  508.     }
  510.     if (newParent.getOwnerDocument() !=fDocument) {
  511.         throw DOM_DOMException(
  512.             DOM_DOMException::WRONG_DOCUMENT_ERR, null);
  513.     }
  515.     int type = newParent.getNodeType();
  516.     if ( !isLegalContainedNode(newParent)
  517.         || type == DOM_Node::DOCUMENT_TYPE_NODE)
  518.     {
  519.         throw DOM_RangeException(
  520.             DOM_RangeException::INVALID_NODE_TYPE_ERR, null);
  521.     }
  523.     DOM_Node root = getCommonAncestorContainer();
  525.     DOM_Node realStart = fStartContainer;
  526.     DOM_Node realEnd = fEndContainer;
  528.     if (fStartContainer.getNodeType() == DOM_Node::TEXT_NODE) {
  529.         realStart = fStartContainer.getParentNode();
  530.     }
  531.     if (fEndContainer.getNodeType() == DOM_Node::TEXT_NODE) {
  532.         realEnd = fEndContainer.getParentNode();
  533.     }
  535.     if (realStart != realEnd) {
  536.         throw DOM_RangeException(
  537.             DOM_RangeException::BAD_BOUNDARYPOINTS_ERR, null);
  538.     }
  540.     DOM_DocumentFragment frag = extractContents();
  541.     insertNode(newParent);
  542.     newParent.appendChild(frag);
  543.     selectNode(newParent);
  544. }
  547. short RangeImpl::compareBoundaryPoints(DOM_Range::CompareHow how, RangeImpl* srcRange) const
  548. {
  549.     if (fDocument != srcRange->fDocument) {
  550.         throw DOM_DOMException(
  551.             DOM_DOMException::WRONG_DOCUMENT_ERR, null);
  552.     }
  553.     if( fDetached) {
  554.         throw DOM_DOMException(
  555.             DOM_DOMException::INVALID_STATE_ERR, null);
  556.     }
  558.     DOM_Node pointA, pointB;
  559.     int offsetA, offsetB;
  561.     switch (how)
  562.     {
  563.     case (DOM_Range::START_TO_START) :
  564.         pointB = srcRange->getStartContainer();
  565.         pointA = fStartContainer;
  566.         offsetB = srcRange->getStartOffset();
  567.         offsetA = fStartOffset;
  568.         break;
  569.     case (DOM_Range::START_TO_END) :
  570.         pointB = srcRange->getStartContainer();
  571.         pointA = fEndContainer;
  572.         offsetB = srcRange->getStartOffset();
  573.         offsetA = fEndOffset;
  574.         break;
  575.     case (DOM_Range::END_TO_START) :
  576.         pointB = srcRange->getEndContainer();
  577.         pointA = fStartContainer;
  578.         offsetB = srcRange->getEndOffset();
  579.         offsetA = fStartOffset;
  580.         break;
  581.     case (DOM_Range::END_TO_END) :
  582.         pointB = srcRange->getEndContainer();
  583.         pointA = fEndContainer;
  584.         offsetB = srcRange->getEndOffset();
  585.         offsetA = fEndOffset;
  586.         break;
  587.     }
  589.     // case 1: same container
  590.     if (pointA == pointB) {
  591.         if (offsetA < offsetB) return -1; //A before B
  592.         if (offsetA == offsetB) return 0; //A equal to B
  593.         return 1; // A after B
  594.     }
  595.     // case 2: Child C of container A is ancestor of B
  596.     for (DOM_Node node = pointA.getFirstChild(); node != null; node=node.getNextSibling()) {
  597.         if (isAncestorOf(node, pointB)) {
  598.             int index = indexOf(node, pointA);
  599.             if (offsetA <=  index) return -1;
  600.             return 1;
  601.         }
  602.     }
  603.     // case 3: Child C of container B is ancestor of A
  604.     for (DOM_Node nd = pointB.getFirstChild(); nd != null; nd=nd.getNextSibling()) {
  605.         if (isAncestorOf(nd, pointA)) {
  606.             int index = indexOf(nd, pointB);
  607.             if (index < offsetB ) return -1;
  608.             return 1; //B strictly before A
  609.         }
  610.     }
  612.     // case 4: preorder traversal of context tree.
  613.     DOM_Node ancestor = commonAncestorOf(pointA, pointB);
  614.     DOM_Node current = ancestor;
  616.     do {
  617.         if (current == pointA) return -1;
  618.         if (current == pointB) return 1;
  619.         current = nextNode(current, true);
  620.     }
  621.     while (current!=null && current!=ancestor);
  623.     return -2; // this should never happen
  624. }
  627. void RangeImpl:: deleteContents()
  628. {
  629.     traverseContents(DELETE_CONTENTS);
  630. }
  632. DOM_DocumentFragment RangeImpl::extractContents()
  633. {
  634.     checkReadOnly(fStartContainer, fEndContainer, fStartOffset, fEndOffset);
  635.     return traverseContents(EXTRACT_CONTENTS);
  636. }
  638. DOM_DocumentFragment RangeImpl::cloneContents() const
  639. {
  640.     // cast off const.
  641.     return ((RangeImpl *)this)->traverseContents(CLONE_CONTENTS);
  642. }
  645. void RangeImpl::insertNode(DOM_Node& newNode)
  646. {
  647.     if (newNode == null) return; //don't have to do anything
  649.     for (DOM_Node aNode = fStartContainer; aNode!=null; aNode = aNode.getParentNode()) {
  650.         if (aNode.fImpl->isReadOnly()) {
  651.         throw DOM_DOMException(
  652.             DOM_DOMException::NO_MODIFICATION_ALLOWED_ERR, null);
  653.     }
  654.     }
  656.     if (fDocument != newNode.getOwnerDocument()) {
  657.         throw DOM_DOMException(
  658.             DOM_DOMException::WRONG_DOCUMENT_ERR, null);
  659.     }
  661.     // Prevent cycles in the tree.
  662.     //isKidOK() is not checked here as its taken care by insertBefore() function
  663.     if (isAncestorOf( newNode, fStartContainer)) {
  664.         throw DOM_DOMException(
  665.             DOM_DOMException::HIERARCHY_REQUEST_ERR, null);
  666.     }
  668.     if( fDetached) {
  669.         throw DOM_DOMException(
  670.             DOM_DOMException::INVALID_STATE_ERR, null);
  671.     }
  673.     int type = newNode.getNodeType();
  674.     if (type == DOM_Node::ATTRIBUTE_NODE
  675.         || type == DOM_Node::ENTITY_NODE
  676.         || type == DOM_Node::NOTATION_NODE
  677.         || type == DOM_Node::DOCUMENT_NODE)
  678.     {
  679.         throw DOM_RangeException(
  680.             DOM_RangeException::INVALID_NODE_TYPE_ERR, null);
  681.     }
  684.     DOM_Node parent;
  685.     DOM_Node next;
  687.     if (fStartContainer.getNodeType() == DOM_Node::TEXT_NODE) {
  689.         //set 'parent' and 'next' here
  690.         parent = fStartContainer.getParentNode();
  692.         //split the text nodes
  693.        if (fStartOffset > 0)
  694.             ((DOM_Text &)fStartContainer).splitText(fStartOffset);
  696.         //update the new start information later. After inserting the first newNode
  697.         if (fStartOffset == 0)
  698.             next = fStartContainer;
  699.         else
  700.             next = fStartContainer.getNextSibling();
  702.     } // end of text handling
  703.     else {
  704.         parent = fStartContainer;
  706.         next = fStartContainer.getFirstChild();
  707.         for(unsigned int i = 0; (i < fStartOffset) && (next != null); i++) {
  708.             next=next.getNextSibling();
  709.         }
  710.     }
  712.     if (parent != null) {
  713.         if (next != null)
  714.             parent.insertBefore(newNode, next);
  715.         else
  716.             parent.appendChild(newNode);
  717.     }
  718. }
  720. RangeImpl* RangeImpl::cloneRange() const
  721. {
  722.     if( fDetached) {
  723.         throw DOM_DOMException(
  724.             DOM_DOMException::INVALID_STATE_ERR, null);
  725.     }
  727.     RangeImpl* range = ((DocumentImpl*)fDocument.fImpl)->createRange();
  728.     range->setStart(fStartContainer, fStartOffset);
  729.     range->setEnd(fEndContainer, fEndOffset);
  731.     return range;
  732. }
  734. DOMString RangeImpl::toString() const
  735. {
  736.     if( fDetached) {
  737.         throw DOM_DOMException(
  738.             DOM_DOMException::INVALID_STATE_ERR, null);
  739.     }
  741.     DOM_Node node = fStartContainer;
  742.     DOM_Node stopNode = fEndContainer;
  744.     DOMString tempString;
  745.     if ( (fStartContainer.getNodeType() == DOM_Node::TEXT_NODE)
  746.         || (fStartContainer.getNodeType() == DOM_Node::CDATA_SECTION_NODE) ) {
  747.         if (fStartContainer == fEndContainer) {
  748.             tempString.appendData(fStartContainer.getNodeValue().substringData(fStartOffset, fEndOffset-fStartOffset));
  749.             return tempString;
  750.         } else {
  751.             int length = fStartContainer.getNodeValue().length();
  752.             tempString.appendData(fStartContainer.getNodeValue().substringData(fStartOffset, length - fStartOffset));
  753.             node = nextNode(node, true);
  754.         }
  755.     }else { //fStartContainer is not a TextNode
  756.         node=node.getFirstChild();
  757.         if (fStartOffset>0) { //find a first node within a range, specified by fStartOffset
  758.             unsigned int counter = 0;
  759.             while (counter<fStartOffset && node!=null) {
  760.                 node=node.getNextSibling();
  761.                 counter++;
  762.             }
  763.         }
  764.         if (node == null) {
  765.             node = nextNode(fStartContainer,false);
  766.         }
  767.     }
  769.     if ( fEndContainer.getNodeType()!= DOM_Node::TEXT_NODE &&
  770.         fEndContainer.getNodeType()!= DOM_Node::CDATA_SECTION_NODE ){
  771.         int i=fEndOffset;
  772.         stopNode = fEndContainer.getFirstChild();
  773.         while( i>0 && stopNode!=null ){
  774.             --i;
  775.             stopNode = stopNode.getNextSibling();
  776.         }
  777.         if ( stopNode == null )
  778.             stopNode = nextNode( fEndContainer, false );
  779.     }
  781.     while (node != stopNode) {  //look into all kids of the Range
  782.         if (node == null) break;
  783.         if (node.getNodeType() == DOM_Node::TEXT_NODE
  784.             ||  node.getNodeType() == DOM_Node::CDATA_SECTION_NODE) {
  785.             tempString.appendData(node.getNodeValue());
  786.         }
  787.         node = nextNode(node, true);
  788.     }
  790.     if (fEndContainer.getNodeType() == DOM_Node::TEXT_NODE
  791.         || fEndContainer.getNodeType() == DOM_Node::CDATA_SECTION_NODE) {
  792.         tempString.appendData(fEndContainer.getNodeValue().substringData(0,fEndOffset));
  793.     }
  794.     return tempString;
  795. }
  797. DOM_Document RangeImpl::getDocument()
  798. {
  799.     return fDocument;
  800. }
  802. const DOM_Node RangeImpl::getCommonAncestorContainer() const
  803. {
  804.      return commonAncestorOf(fStartContainer, fEndContainer);
  806. }
  808. //---------------------
  809. //private functions
  810. //---------------------
  812. bool RangeImpl::isValidAncestorType(const DOM_Node& node) const
  813. {
  814.     for (DOM_Node aNode = node; aNode!=null; aNode = aNode.getParentNode()) {
  815.         short type = aNode.getNodeType();
  816.         if ( type == DOM_Node::ENTITY_NODE
  817.             || type == DOM_Node::NOTATION_NODE
  818.             || type == DOM_Node::DOCUMENT_TYPE_NODE)
  819.             return false;
  820.     }
  821.     return true;
  822. }
  824. bool RangeImpl::isAncestorOf(const DOM_Node& a, const DOM_Node& b) {
  825.     for (DOM_Node node=b; node != null; node=node.getParentNode()) {
  826.         if  (node == a) return true;
  827.     }
  828.     return false;
  829. }
  831. bool RangeImpl::hasLegalRootContainer(const DOM_Node& node) const {
  832.     if ( node==null )
  833.         return false;
  835.     DOM_Node rootContainer = node;
  836.     for (; rootContainer.getParentNode()!=null; rootContainer = rootContainer.getParentNode())
  837.         ;
  839.     switch( rootContainer.getNodeType() ) {
  840.         case DOM_Node::ATTRIBUTE_NODE:
  841.         case DOM_Node::DOCUMENT_NODE:
  842.         case DOM_Node::DOCUMENT_FRAGMENT_NODE:
  843.         return true;
  844.     }
  845.     return false;
  846. }
  848. bool RangeImpl::isLegalContainedNode(const DOM_Node& node ) const {
  849.    if ( node==null )
  850.        return false;
  851.    switch( node.getNodeType() )
  852.    {
  853.        case DOM_Node::DOCUMENT_NODE:
  854.        case DOM_Node::DOCUMENT_FRAGMENT_NODE:
  855.        case DOM_Node::ATTRIBUTE_NODE:
  856.        case DOM_Node::ENTITY_NODE:
  857.        case DOM_Node::NOTATION_NODE:
  858.        return false;
  859.    }
  860.    return true;
  861. }
  863. unsigned short RangeImpl::indexOf(const DOM_Node& child, const DOM_Node& parent) const
  864. {
  865.     unsigned short i = 0;
  866.     if (child.getParentNode() != parent) return (unsigned short)-1;
  867.     for(DOM_Node node = child.getPreviousSibling(); node!= null; node=node.getPreviousSibling()) {
  868.         i++;
  869.     }
  870.     return i;
  871. }
  873. void RangeImpl::validateNode(const DOM_Node& node) const
  874. {
  875.     if( fDetached) {
  876.         throw DOM_DOMException(
  877.             DOM_DOMException::INVALID_STATE_ERR, null);
  878.     }
  880.     if ( !isValidAncestorType(node)) {
  881.         throw DOM_RangeException(
  882.             DOM_RangeException::INVALID_NODE_TYPE_ERR, null);
  883.     }
  884. }
  887. const DOM_Node RangeImpl::commonAncestorOf(const DOM_Node& pointA, const DOM_Node& pointB) const
  888. {
  889.     if (fDetached)
  890.             throw DOM_DOMException(DOM_DOMException::INVALID_STATE_ERR, null);
  892.     if (pointA.getOwnerDocument() != pointB.getOwnerDocument())
  893.         throw DOM_DOMException( DOM_DOMException::WRONG_DOCUMENT_ERR, null );
  895.     //if the containers are same then it itself is its common ancestor.
  896.     if (pointA == pointB)
  897.         return pointA;
  899.     typedef RefVectorOf<NodeImpl> VectorNodes;
  900.     VectorNodes* startV= new (((DocumentImpl*)fDocument.fImpl)->getMemoryManager()) VectorNodes(1, false, ((DocumentImpl*)fDocument.fImpl)->getMemoryManager());
  901.     DOM_Node node;
  903.     for (node=fStartContainer; node != null; node=node.getParentNode())
  904.     {
  905.         startV->addElement(node.fImpl);
  906.     }
  907.     VectorNodes* endV = new (((DocumentImpl*)fDocument.fImpl)->getMemoryManager()) VectorNodes(1, false, ((DocumentImpl*)fDocument.fImpl)->getMemoryManager());
  908.     for (node=fEndContainer; node != null; node=node.getParentNode())
  909.     {
  910.         endV->addElement(node.fImpl);
  911.     }
  913.     int s = startV->size()-1;
  914.     int e = endV->size()-1;
  916.     NodeImpl* commonAncestor;
  918.     while (s>=0 && e>=0) {
  919.         if (startV->elementAt(s) == endV->elementAt(e)) {
  920.             commonAncestor = startV->elementAt(s);
  921.         }
  922.         else  break;
  923.         --s;
  924.         --e;
  925.     }
  927.     delete startV;
  928.     delete endV;
  930.     return DOM_Node(commonAncestor);
  931. }
  933. void RangeImpl::checkIndex(const DOM_Node& node, unsigned int offset) const
  934. {
  935.     if (offset < 0) {
  936.         throw DOM_DOMException( DOM_DOMException::INDEX_SIZE_ERR, null );
  937.     }
  939.     short type = node.getNodeType();
  941.     if((type == DOM_Node::TEXT_NODE
  942.         || type == DOM_Node::CDATA_SECTION_NODE
  943.         || type == DOM_Node::COMMENT_NODE
  944.         || type == DOM_Node::PROCESSING_INSTRUCTION_NODE)) {
  945.         if (offset > node.getNodeValue().length())
  946.             throw DOM_DOMException( DOM_DOMException::INDEX_SIZE_ERR, null );
  947.         else  return;
  948.     }
  950.     DOM_Node child = node.getFirstChild();
  951.     unsigned int i = 0;
  952.     for (; child != null; i++) {
  953.         child = child.getNextSibling();
  954.     }
  955.     if (i < offset) {
  956.         throw DOM_DOMException( DOM_DOMException::INDEX_SIZE_ERR, null );
  957.     }
  959. }
  961. DOM_Node RangeImpl::nextNode(const DOM_Node& node, bool visitChildren) const
  962. {
  964.     if (node == null) return null;
  966.     DOM_Node result;
  967.     if (visitChildren) {
  968.         result = node.getFirstChild();
  969.         if (result != null) {
  970.             return result;
  971.         }
  972.     }
  974.     // if hasSibling, return sibling
  975.     result = node.getNextSibling();
  976.     if (result != null) {
  977.         return result;
  978.     }
  981.     // return parent's 1st sibling.
  982.     DOM_Node parent = node.getParentNode();
  985.     while ( (parent != null) && (parent != fDocument) )
  986.     {
  987.         result = parent.getNextSibling();
  988.         if (result != null) {
  989.             return result;
  990.         } else {
  991.             parent = parent.getParentNode();
  992.             if (parent == fEndContainer) return parent;
  994.         }
  996.     }
  997.     // end of list, return null
  998.     return null;
  999. }
  1002. /** This is the master routine invoked to visit the nodes
  1003. *   selected by this range.  For each such node, different
  1004. *   actions are taken depending on the value of the TraversalType argument.
  1005. */
  1006. DOM_DocumentFragment RangeImpl::traverseContents(TraversalType how)
  1007. {
  1008.     if (fDetached)
  1009.             throw DOM_DOMException(DOM_DOMException::INVALID_STATE_ERR, null);
  1011.     if (fStartContainer == null || fEndContainer == null) {
  1012.         return DOM_DocumentFragment(); // REVIST: Throw exception?
  1013.     }
  1015.     /* Traversal is accomplished by first determining the
  1016.        relationship between the endpoints of the range.
  1017.        For each of four significant relationships, we will
  1018.        delegate the traversal call to a method that
  1019.        can make appropriate assumptions.
  1020.     */
  1022.     // case 1: same container
  1023.     if ( fStartContainer == fEndContainer )
  1024.         return traverseSameContainer( how );
  1026.     // case 2: Child C of start container is ancestor of end container
  1027.     for (DOM_Node node = fStartContainer.getFirstChild(); node != null; node=node.getNextSibling()) {
  1028.         if (isAncestorOf(node, fEndContainer))
  1029.             return traverseCommonStartContainer( node, how );
  1030.     }
  1032.     // case 3: Child C of end container  is ancestor of start container
  1033.     for (DOM_Node nd = fEndContainer.getFirstChild(); nd != null; nd=nd.getNextSibling()) {
  1034.         if (isAncestorOf(nd, fStartContainer))
  1035.              return traverseCommonEndContainer( nd, how );
  1036.         }
  1038.     // case 4: preorder traversal of context tree.
  1039.     // There is a common ancestor container.  Find the
  1040.     // ancestor siblings that are children of that container.
  1041.     DOM_Node ancestor = commonAncestorOf(fStartContainer, fEndContainer);
  1042.     return traverseCommonAncestors( ancestor, ancestor, how );
  1043.     }
  1045. /**
  1046.  * Visits the nodes selected by this range when we know
  1047.  * a-priori that the start and end containers are the same.
  1048.  *
  1049.  */
  1050. DOM_DocumentFragment RangeImpl::traverseSameContainer( int how )
  1051. {
  1052.     DOM_DocumentFragment frag = null;
  1053.     if ( how!=DELETE_CONTENTS)
  1054.         frag = fDocument.createDocumentFragment();
  1056.     // If selection is empty, just return the fragment
  1057.     if ( fStartOffset==fEndOffset )
  1058.             return frag;
  1060.     DOM_Node current = fStartContainer;
  1061.     DOM_Node cloneCurrent = null;
  1063.     // Text node needs special case handling
  1064.     if ( fStartContainer.getNodeType()== DOM_Node::TEXT_NODE )
  1065.     {
  1066.         cloneCurrent = fStartContainer.cloneNode(false);
  1067.         cloneCurrent.setNodeValue(
  1068.             cloneCurrent.getNodeValue().substringData(fStartOffset, fEndOffset - fStartOffset));
  1070.         // set the original text node to its new value
  1071.         if ( how != CLONE_CONTENTS )
  1072.             ((DOM_Text &)fStartContainer).deleteData(fStartOffset, fEndOffset-fStartOffset);
  1073.         if ( how != DELETE_CONTENTS)
  1074.             frag.appendChild(cloneCurrent);
  1075.     }
  1076.     else {
  1077.         // Copy nodes between the start/end offsets.
  1078.         DOM_Node n = getSelectedNode( fStartContainer, fStartOffset );
  1079.         int cnt = fEndOffset - fStartOffset;
  1080.         while( cnt > 0 )
  1081.         {
  1082.             DOM_Node sibling = n.getNextSibling();
  1083.             DOM_Node xferNode = traverseFullySelected( n, how );
  1084.             if ( frag!=null )
  1085.                 frag.appendChild( xferNode );
  1086.             --cnt;
  1087.             n = sibling;
  1088.             }
  1089.     }
  1091.     // Nothing is partially selected, so collapse to start point
  1092.     if ( how != CLONE_CONTENTS )
  1093.             collapse(true);
  1094.     return frag;
  1095. }
  1097. /**
  1098.  * Visits the nodes selected by this range when we know
  1099.  * a-priori that the start and end containers are not the
  1100.  * same, but the start container is an ancestor of the end container
  1101.  *
  1102.  */
  1103. DOM_DocumentFragment RangeImpl::traverseCommonStartContainer( DOM_Node endAncestor, int how )
  1104. {
  1105.     DOM_DocumentFragment frag = null;
  1106.     if ( how!=DELETE_CONTENTS)
  1107.         frag = fDocument.createDocumentFragment();
  1108.     DOM_Node n = traverseRightBoundary( endAncestor, how );
  1109.     if ( frag!=null )
  1110.         frag.appendChild( n );
  1112.     int endIdx = indexOf( endAncestor, fStartContainer );
  1113.     int cnt = endIdx - fStartOffset;
  1114.     if ( cnt <=0 )
  1115.     {
  1116.         // Collapse to just before the endAncestor, which
  1117.         // is partially selected.
  1118.         if ( how != CLONE_CONTENTS )
  1119.         {
  1120.             setEndBefore( endAncestor );
  1121.             collapse( false );
  1122.         }
  1123.         return frag;
  1124.     }
  1126.     n = endAncestor.getPreviousSibling();
  1127.     while( cnt > 0 )
  1128.     {
  1129.         DOM_Node sibling = n.getPreviousSibling();
  1130.         DOM_Node xferNode = traverseFullySelected( n, how );
  1131.         if ( frag!=null )
  1132.             frag.insertBefore( xferNode, frag.getFirstChild() );
  1133.         --cnt;
  1134.         n = sibling;
  1135.     }
  1136.     // Collapse to just before the endAncestor, which
  1137.     // is partially selected.
  1138.     if ( how != CLONE_CONTENTS )
  1139.     {
  1140.         setEndBefore( endAncestor );
  1141.         collapse( false );
  1142.     }
  1143.     return frag;
  1144. }
  1146. /**
  1147.  * Visits the nodes selected by this range when we know
  1148.  * a-priori that the start and end containers are not the
  1149.  * same, but the end container is an ancestor of the start container
  1150.  *
  1151.  */
  1152. DOM_DocumentFragment RangeImpl::traverseCommonEndContainer( DOM_Node startAncestor, int how )
  1153. {
  1154.     DOM_DocumentFragment frag = null;
  1155.     if ( how!=DELETE_CONTENTS)
  1156.         frag = fDocument.createDocumentFragment();
  1157.     DOM_Node n = traverseLeftBoundary( startAncestor, how );
  1158.     if ( frag!=null )
  1159.         frag.appendChild( n );
  1160.     int startIdx = indexOf( startAncestor, fEndContainer );
  1161.     ++startIdx;  // Because we already traversed it....
  1163.     int cnt = fEndOffset - startIdx;
  1164.     n = startAncestor.getNextSibling();
  1165.     while( cnt > 0 )
  1166.     {
  1167.         DOM_Node sibling = n.getNextSibling();
  1168.         DOM_Node xferNode = traverseFullySelected( n, how );
  1169.         if ( frag!=null )
  1170.             frag.appendChild( xferNode );
  1171.         --cnt;
  1172.         n = sibling;
  1173.     }
  1175.     if ( how != CLONE_CONTENTS )
  1176.     {
  1177.         setStartAfter( startAncestor );
  1178.         collapse( true );
  1179.     }
  1181.     return frag;
  1182. }
  1184. /**
  1185.  * Visits the nodes selected by this range when we know
  1186.  * a-priori that the start and end containers are not
  1187.  * the same, and we also know that neither the start
  1188.  * nor end container is an ancestor of the other.
  1189.  */
  1190. DOM_DocumentFragment RangeImpl::traverseCommonAncestors( DOM_Node startAncestor, DOM_Node endAncestor, int how )
  1191. {
  1192.     DOM_DocumentFragment frag = null;
  1193.     if ( how!=DELETE_CONTENTS)
  1194.         frag = fDocument.createDocumentFragment();
  1196.     DOM_Node n = traverseLeftBoundary( startAncestor, how );
  1197.     if ( frag!=null )
  1198.         frag.appendChild( n );
  1200.     DOM_Node commonParent = startAncestor.getParentNode();
  1201.     int startOffset = indexOf( startAncestor, commonParent );
  1202.     int endOffset = indexOf( endAncestor, commonParent );
  1203.     ++startOffset;
  1205.     int cnt = endOffset - startOffset;
  1206.     DOM_Node sibling = startAncestor.getNextSibling();
  1208.     while( cnt > 0 )
  1209.     {
  1210.         DOM_Node nextSibling = sibling.getNextSibling();
  1211.         n = traverseFullySelected( sibling, how );
  1212.         if ( frag!=null )
  1213.             frag.appendChild( n );
  1214.         sibling = nextSibling;
  1215.         --cnt;
  1216.     }
  1218.     n = traverseRightBoundary( endAncestor, how );
  1219.     if ( frag!=null )
  1220.         frag.appendChild( n );
  1222.     if ( how != CLONE_CONTENTS )
  1223.     {
  1224.         setStartAfter( startAncestor );
  1225.         collapse( true );
  1226.     }
  1227.     return frag;
  1228. }
  1230. /**
  1231.  * Traverses the "right boundary" of this range and
  1232.  * operates on each "boundary node" according to the
  1233.  * how parameter.  It is a-priori assumed
  1234.  * by this method that the right boundary does
  1235.  * not contain the range's start container.
  1236.  *
  1237.  * A "right boundary" is best visualized by thinking
  1238.  * of a sample tree:
  1239.  *                 A
  1240.  *                /|
  1241.  *               / | 
  1242.  *              /  |  
  1243.  *             B   C   D
  1244.  *            /|     /|
  1245.  *           E F G   H I J
  1246.  *
  1247.  * Imagine first a range that begins between the
  1248.  * "E" and "F" nodes and ends between the
  1249.  * "I" and "J" nodes.  The start container is
  1250.  * "B" and the end container is "D".  Given this setup,
  1251.  * the following applies:
  1252.  *
  1253.  * Partially Selected Nodes: B, D<br>
  1254.  * Fully Selected Nodes: F, G, C, H, I
  1255.  *
  1256.  * The "right boundary" is the highest subtree node
  1257.  * that contains the ending container.  The root of
  1258.  * this subtree is always partially selected.
  1259.  *
  1260.  * In this example, the nodes that are traversed
  1261.  * as "right boundary" nodes are: H, I, and D.
  1262.  *
  1263.  */
  1264. DOM_Node RangeImpl::traverseRightBoundary( DOM_Node root, int how )
  1265. {
  1266.     DOM_Node next = getSelectedNode( fEndContainer, fEndOffset-1 );
  1267.     bool isFullySelected = ( next!=fEndContainer );
  1269.     if ( next==root )
  1270.         return traverseNode( next, isFullySelected, false, how );
  1272.     DOM_Node parent = next.getParentNode();
  1273.     DOM_Node clonedParent = traverseNode( parent, false, false, how );
  1275.     while( parent!=null )
  1276.     {
  1277.         while( next!=null )
  1278.         {
  1279.             DOM_Node prevSibling = next.getPreviousSibling();
  1280.             DOM_Node clonedChild =
  1281.                 traverseNode( next, isFullySelected, false, how );
  1282.             if ( how!=DELETE_CONTENTS )
  1283.             {
  1284.                 clonedParent.insertBefore(
  1285.                     clonedChild,
  1286.                     clonedParent.getFirstChild()
  1287.                 );
  1288.             }
  1289.             isFullySelected = true;
  1290.             next = prevSibling;
  1291.         }
  1292.         if ( parent==root )
  1293.             return clonedParent;
  1295.         next = parent.getPreviousSibling();
  1296.         parent = parent.getParentNode();
  1297.         DOM_Node clonedGrandParent = traverseNode( parent, false, false, how );
  1298.         if ( how!=DELETE_CONTENTS )
  1299.             clonedGrandParent.appendChild( clonedParent );
  1300.         clonedParent = clonedGrandParent;
  1302.     }
  1304.     // should never occur
  1305.     return null;
  1306. }
  1308. /**
  1309.  * Traverses the "left boundary" of this range and
  1310.  * operates on each "boundary node" according to the
  1311.  * how parameter.  It is a-priori assumed
  1312.  * by this method that the left boundary does
  1313.  * not contain the range's end container.
  1314.  *
  1315.  * A "left boundary" is best visualized by thinking
  1316.  * of a sample tree:
  1317.  *
  1318.  *                 A
  1319.  *                /|
  1320.  *               / | 
  1321.  *              /  |  
  1322.  *             B   C   D
  1323.  *            /|     /|
  1324.  *           E F G   H I J
  1325.  *
  1326.  * Imagine first a range that begins between the
  1327.  * "E" and "F" nodes and ends between the
  1328.  * "I" and "J" nodes.  The start container is
  1329.  * "B" and the end container is "D".  Given this setup,
  1330.  * the following applies:
  1331.  *
  1332.  * Partially Selected Nodes: B, D<br>
  1333.  * Fully Selected Nodes: F, G, C, H, I
  1334.  *
  1335.  * The "left boundary" is the highest subtree node
  1336.  * that contains the starting container.  The root of
  1337.  * this subtree is always partially selected.
  1338.  *
  1339.  * In this example, the nodes that are traversed
  1340.  * as "left boundary" nodes are: F, G, and B.
  1341.  *
  1342.  */
  1343. DOM_Node RangeImpl::traverseLeftBoundary( DOM_Node root, int how )
  1344. {
  1345.     DOM_Node next = getSelectedNode( getStartContainer(), getStartOffset() );
  1346.     bool isFullySelected = ( next!=getStartContainer() );
  1348.     if ( next==root )
  1349.         return traverseNode( next, isFullySelected, true, how );
  1351.     DOM_Node parent = next.getParentNode();
  1352.     DOM_Node clonedParent = traverseNode( parent, false, true, how );
  1354.     while( parent!=null )
  1355.     {
  1356.         while( next!=null )
  1357.         {
  1358.             DOM_Node nextSibling = next.getNextSibling();
  1359.             DOM_Node clonedChild =
  1360.                 traverseNode( next, isFullySelected, true, how );
  1361.             if ( how!=DELETE_CONTENTS )
  1362.                 clonedParent.appendChild(clonedChild);
  1363.             isFullySelected = true;
  1364.             next = nextSibling;
  1365.         }
  1366.         if ( parent==root )
  1367.             return clonedParent;
  1369.         next = parent.getNextSibling();
  1370.         parent = parent.getParentNode();
  1371.         DOM_Node clonedGrandParent = traverseNode( parent, false, true, how );
  1372.         if ( how!=DELETE_CONTENTS )
  1373.             clonedGrandParent.appendChild( clonedParent );
  1374.         clonedParent = clonedGrandParent;
  1376.     }
  1378.     // should never occur
  1379.     return null;
  1381. }
  1383. /**
  1384.  * Utility method for traversing a single node.
  1385.  * Does not properly handle a text node containing both the
  1386.  * start and end offsets.  Such nodes should
  1387.  * have been previously detected and been routed to traverseTextNode.
  1388.  *
  1389.  */
  1390. DOM_Node RangeImpl::traverseNode( DOM_Node n, bool isFullySelected, bool isLeft, int how )
  1391. {
  1392.     if ( isFullySelected )
  1393.         return traverseFullySelected( n, how );
  1394.     if ( n.getNodeType()== DOM_Node::TEXT_NODE )
  1395.         return traverseTextNode( n, isLeft, how );
  1396.     return traversePartiallySelected( n, how );
  1397. }
  1399. /**
  1400.  * Utility method for traversing a single node when
  1401.  * we know a-priori that the node if fully
  1402.  * selected.
  1403.  *
  1404.  */
  1405. DOM_Node RangeImpl::traverseFullySelected( DOM_Node n, int how )
  1406. {
  1407.     switch( how )
  1408.     {
  1409.     case CLONE_CONTENTS:
  1410.         return n.cloneNode( true );
  1411.     case EXTRACT_CONTENTS:
  1412.         if ( n.getNodeType()== DOM_Node::DOCUMENT_TYPE_NODE )
  1413.         {
  1414.             throw DOM_DOMException(
  1415.                 DOM_DOMException::HIERARCHY_REQUEST_ERR, null);
  1416.         }
  1417.         return n;
  1418.     case DELETE_CONTENTS:
  1419.         n.getParentNode().removeChild(n);
  1420.         return null;
  1421.     }
  1422.     return null;
  1423. }
  1425. /**
  1426.  * Utility method for traversing a single node when
  1427.  * we know a-priori that the node if partially
  1428.  * selected and is not a text node.
  1429.  *
  1430.  */
  1431. DOM_Node RangeImpl::traversePartiallySelected( DOM_Node n, int how )
  1432. {
  1433.     switch( how )
  1434.     {
  1435.     case DELETE_CONTENTS:
  1436.         return null;
  1437.     case CLONE_CONTENTS:
  1438.     case EXTRACT_CONTENTS:
  1439.         return n.cloneNode( false );
  1440.     }
  1441.     return null;
  1442. }
  1444. /**
  1445.  * Utility method for traversing a text node that we know
  1446.  * a-priori to be on a left or right boundary of the range.
  1447.  * This method does not properly handle text nodes that contain
  1448.  * both the start and end points of the range.
  1449.  *
  1450.  */
  1451. DOM_Node RangeImpl::traverseTextNode( DOM_Node n, bool isLeft, int how )
  1452. {
  1453.     DOMString txtValue = n.getNodeValue();
  1454.     DOMString newNodeValue;
  1455.     DOMString oldNodeValue;
  1457.     if ( isLeft )
  1458.     {
  1459.         int offset = getStartOffset();
  1460.         newNodeValue = txtValue.substringData( offset , fStartContainer.getNodeValue().length()-offset);
  1461.         oldNodeValue = txtValue.substringData( 0, offset );
  1462.     }
  1463.     else
  1464.     {
  1465.         int offset = getEndOffset();
  1466.         newNodeValue = txtValue.substringData( 0, offset );
  1467.         oldNodeValue = txtValue.substringData( offset , fEndContainer.getNodeValue().length()-offset );
  1468.     }
  1470.     if ( how != CLONE_CONTENTS )
  1471.         n.setNodeValue( oldNodeValue );
  1472.     if ( how==DELETE_CONTENTS )
  1473.         return null;
  1474.     DOM_Node newNode = n.cloneNode( false );
  1475.     newNode.setNodeValue( newNodeValue );
  1476.     return newNode;
  1477. }
  1479. /**
  1480.  * Utility method to retrieve a child node by index.  This method
  1481.  * assumes the caller is trying to find out which node is
  1482.  * selected by the given index.  Note that if the index is
  1483.  * greater than the number of children, this implies that the
  1484.  * first node selected is the parent node itself.
  1485.  *
  1486.  */
  1487. DOM_Node RangeImpl::getSelectedNode( DOM_Node container, int offset )
  1488. {
  1489.     if ( container.getNodeType() == DOM_Node::TEXT_NODE )
  1490.         return container;
  1492.     // This case is an important convenience for
  1493.     // traverseRightBoundary()
  1494.     if ( offset<0 )
  1495.         return container;
  1497.     DOM_Node child = container.getFirstChild();
  1498.     while( child!=null && offset > 0 )
  1499.     {
  1500.         --offset;
  1501.         child = child.getNextSibling();
  1502.     }
  1503.     if ( child!=null )
  1504.         return child;
  1505.     return container;
  1506. }
  1508. void RangeImpl::checkReadOnly(DOM_Node& start, DOM_Node& end,
  1509.                               unsigned int startOffset, unsigned int endOffset)
  1510. {
  1511.     if ((start == null) || (end == null) ) return;
  1512.     //if both start and end are text check and return
  1513.     if (start.getNodeType() == DOM_Node::TEXT_NODE) {
  1514.         if (start.fImpl->isReadOnly()) {
  1515.             throw DOM_DOMException(
  1516.                 DOM_DOMException::NO_MODIFICATION_ALLOWED_ERR, null);
  1517.         }
  1518.         if (start == end)
  1519.             return;
  1520.     }
  1521.     //set the start and end nodes to check
  1522.     DOM_Node sNode = start.getFirstChild();
  1523.     for(unsigned int i = 0; i<startOffset; i++)
  1524.         sNode = sNode.getNextSibling();
  1526.     DOM_Node eNode;
  1527.     if (end.getNodeType() == DOM_Node::TEXT_NODE) {
  1528.         eNode = end; //need to check only till this node
  1529.     }
  1530.     else { //need to check all the kids that fall before the end offset value
  1531.         eNode = end.getFirstChild();
  1532.         for (unsigned int i = 0; i<endOffset-1; i++)
  1533.             eNode = eNode.getNextSibling();
  1534.     }
  1535.     //recursivly search if any node is readonly
  1536.     recurseTreeAndCheck(sNode, eNode);
  1537. }
  1539. void RangeImpl::recurseTreeAndCheck(DOM_Node& start, DOM_Node& end)
  1540. {
  1541.     for(DOM_Node node=start; node != null && node !=end; node=node.getNextSibling())
  1542.     {
  1543.         if (node.fImpl->isReadOnly()) {
  1544.             throw DOM_DOMException(
  1545.                 DOM_DOMException::NO_MODIFICATION_ALLOWED_ERR, null);
  1546.         }
  1548.         if (node.hasChildNodes()) {
  1549.             node = node.getFirstChild();
  1550.             recurseTreeAndCheck(node, end);
  1551.         }
  1552.     }
  1553. }
  1556. DOM_Node RangeImpl::removeChild(DOM_Node& parent, DOM_Node& child)
  1557. {
  1558.     fRemoveChild = child; //only a precaution measure not to update this range data before removal
  1559.     DOM_Node n = parent.removeChild(child);
  1560.     fRemoveChild = null;
  1561.     return n;
  1562. }
  1565. //
  1566. // Mutation functions
  1567. //
  1570. /* This function is called from DOM.
  1571. *  The  text has already beeen replaced.
  1572. *  Fix-up any offsets.
  1573. */
  1574. void RangeImpl::receiveReplacedText(NodeImpl* node)
  1575. {
  1576.     if (node == null) return;
  1577.     DOM_Node anode(node);
  1578.     if (anode == fStartContainer
  1579.         && fStartContainer.getNodeType() == DOM_Node::TEXT_NODE) {
  1580.         fStartOffset = 0;
  1581.     }
  1582.     if (anode == fEndContainer
  1583.         && fEndContainer.getNodeType() == DOM_Node::TEXT_NODE) {
  1584.         fEndOffset = 0;
  1585.     }
  1586. }
  1589. /** This function is called from DOM.
  1590. *  The  text has already beeen inserted.
  1591. *  Fix-up any offsets.
  1592. */
  1593. void RangeImpl::updateRangeForDeletedText(DOM_Node& node, unsigned int offset, int count)
  1594. {
  1595.     if (node == null) return;
  1597.     if (node == fStartContainer
  1598.         && fStartContainer.getNodeType() == DOM_Node::TEXT_NODE) {
  1599.         if (fStartOffset > offset+count) {
  1600.             fStartOffset = fStartOffset-count;
  1601.         } else if (fStartOffset > offset) {
  1602.             fStartOffset = offset;
  1603.         }
  1604.     }
  1605.     if (node == fEndContainer
  1606.         && fEndContainer.getNodeType() == DOM_Node::TEXT_NODE) {
  1607.         if (fEndOffset > offset+count) {
  1608.             fEndOffset = fEndOffset-count;
  1609.         } else if (fEndOffset > offset) {
  1610.             fEndOffset = offset;
  1611.         }
  1612.     }
  1613. }
  1617. /** This function must be called by the DOM _BEFORE_
  1618. *  a node is deleted, because at that time it is
  1619. *  connected in the DOM tree, which we depend on.
  1620. */
  1621. void RangeImpl::updateRangeForDeletedNode(NodeImpl* node)
  1622. {
  1624.     if (node == null) return;
  1625.     if (fRemoveChild == node) return;
  1627.     DOM_Node tNode(node);
  1629.     if (node->getParentNode() == fStartContainer.fImpl) {
  1630.         unsigned short index = indexOf(tNode, fStartContainer);
  1631.         if ( fStartOffset > index) {
  1632.             fStartOffset--;
  1633.         }
  1634.     }
  1636.     if (node->getParentNode() == fEndContainer.fImpl) {
  1637.         unsigned short index = indexOf(tNode, fEndContainer);
  1638.         if ( fEndOffset > index) {
  1639.             fEndOffset--;
  1640.         }
  1641.     }
  1643.     if (node->getParentNode() != fStartContainer.fImpl
  1644.         ||  node->getParentNode() != fEndContainer.fImpl) {
  1645.         if (isAncestorOf(node, fStartContainer)) {
  1646.             DOM_Node tpNode(node->getParentNode());
  1647.             setStartContainer( tpNode );
  1648.             fStartOffset = indexOf( tNode, tpNode);
  1649.         }
  1650.         if (isAncestorOf(node, fEndContainer)) {
  1651.             DOM_Node tpNode(node->getParentNode());
  1652.             setEndContainer( tpNode );
  1653.             fEndOffset = indexOf( tNode, tpNode);
  1654.         }
  1655.     }
  1657. }
  1659. void RangeImpl::updateRangeForInsertedNode(NodeImpl* node) {
  1660.     if (node == null) return;
  1662.     if (node->getParentNode() == fStartContainer.fImpl) {
  1663.         unsigned int index = indexOf(DOM_Node(node), fStartContainer);
  1664.         if (index < fStartOffset) {
  1665.             fStartOffset++;
  1666.         }
  1667.     }
  1669.     if (node->getParentNode() == fEndContainer.fImpl) {
  1670.         unsigned int index = indexOf(DOM_Node(node), fEndContainer);
  1671.         if (index < fEndOffset) {
  1672.             fEndOffset++;
  1673.         }
  1674.     }
  1675. }
  1678. void RangeImpl::updateSplitInfo(TextImpl* oldNode, TextImpl* startNode, unsigned int offset)
  1679. {
  1680.     if (startNode == null) return;
  1682.     DOM_Text oldText(oldNode);
  1683.     DOM_Text newText(startNode);
  1685.     if (fStartContainer == oldText && fStartOffset > offset) {
  1686.           fStartOffset = fStartOffset - offset;
  1687.         fStartContainer = newText;
  1688.     }
  1690.     if (fEndContainer == oldText && fEndOffset > offset) {
  1691.             fEndContainer = newText;
  1692.        fEndOffset = fEndOffset - offset;
  1693.     }
  1694. }
  1697. XERCES_CPP_NAMESPACE_END