DOMRangeImpl.hpp
上传用户:zhuqijet
上传日期:2013-06-25
资源大小:10074k
文件大小:8k
源码类别:

词法分析

开发平台:

Visual C++

  1. #ifndef DOMRangeImpl_HEADER_GUARD_
  2. #define DOMRangeImpl_HEADER_GUARD_
  3. /*
  4.  * The Apache Software License, Version 1.1
  5.  *
  6.  * Copyright (c) 2001-2002 The Apache Software Foundation.  All rights
  7.  * reserved.
  8.  *
  9.  * Redistribution and use in source and binary forms, with or without
  10.  * modification, are permitted provided that the following conditions
  11.  * are met:
  12.  *
  13.  * 1. Redistributions of source code must retain the above copyright
  14.  *    notice, this list of conditions and the following disclaimer.
  15.  *
  16.  * 2. Redistributions in binary form must reproduce the above copyright
  17.  *    notice, this list of conditions and the following disclaimer in
  18.  *    the documentation and/or other materials provided with the
  19.  *    distribution.
  20.  *
  21.  * 3. The end-user documentation included with the redistribution,
  22.  *    if any, must include the following acknowledgment:
  23.  *       "This product includes software developed by the
  24.  *        Apache Software Foundation (http://www.apache.org/)."
  25.  *    Alternately, this acknowledgment may appear in the software itself,
  26.  *    if and wherever such third-party acknowledgments normally appear.
  27.  *
  28.  * 4. The names "Xerces" and "Apache Software Foundation" must
  29.  *    not be used to endorse or promote products derived from this
  30.  *    software without prior written permission. For written
  31.  *    permission, please contact apache@apache.org.
  32.  *
  33.  * 5. Products derived from this software may not be called "Apache",
  34.  *    nor may "Apache" appear in their name, without prior written
  35.  *    permission of the Apache Software Foundation.
  36.  *
  37.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  38.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  39.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  40.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  41.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  42.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  43.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  44.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  45.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  46.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  47.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  48.  * SUCH DAMAGE.
  49.  * ====================================================================
  50.  *
  51.  * This software consists of voluntary contributions made by many
  52.  * individuals on behalf of the Apache Software Foundation, and was
  53.  * originally based on software copyright (c) 2001, International
  54.  * Business Machines, Inc., http://www.ibm.com .  For more information
  55.  * on the Apache Software Foundation, please see
  56.  * <http://www.apache.org/>.
  57.  */
  58.  /*
  59.  * $Id: DOMRangeImpl.hpp,v 1.5 2003/01/16 20:12:19 tng Exp $
  60.  */
  61. //
  62. //  This file is part of the internal implementation of the C++ XML DOM.
  63. //  It should NOT be included or used directly by application programs.
  64. //
  65. //  Applications should include the file <xercesc/dom/DOM.hpp> for the entire
  66. //  DOM API, or xercesc/dom/DOM*.hpp for individual DOM classes, where the class
  67. //  name is substituded for the *.
  68. //
  69. #include <xercesc/util/XercesDefs.hpp>
  70. #include <xercesc/dom/DOMRange.hpp>
  71. XERCES_CPP_NAMESPACE_BEGIN
  72. class       DOMNode;
  73. class       DOMDocumentFragment;
  74. class       DOMDocument;
  75. class       DOMText;
  76. class CDOM_EXPORT DOMRangeImpl: public DOMRange {
  77. private:
  78.     enum TraversalType {
  79.         EXTRACT_CONTENTS = 1,
  80.         CLONE_CONTENTS   = 2,
  81.         DELETE_CONTENTS  = 3
  82.     };
  83.     enum TraversePoint {
  84.         BEFORE  = -1,
  85.         START   = 0,
  86.         AFTER   = 1
  87.     };
  88.     //private data
  89.     DOMNode*     fStartContainer;
  90.     XMLSize_t    fStartOffset;
  91.     DOMNode*     fEndContainer;
  92.     XMLSize_t    fEndOffset;
  93.     bool         fCollapsed;
  94.     DOMDocument* fDocument;
  95.     bool         fDetached;
  96.     DOMNode*     fRemoveChild;
  97. public:
  98.     //c'tor
  99.     DOMRangeImpl(DOMDocument* doc);
  100.     DOMRangeImpl(const DOMRangeImpl& other);
  101.     //d'tor
  102.     ~DOMRangeImpl();
  103.     //getter functions
  104.     virtual DOMNode* getStartContainer() const;
  105.     virtual XMLSize_t getStartOffset() const;
  106.     virtual DOMNode* getEndContainer() const;
  107.     virtual XMLSize_t getEndOffset() const;
  108.     virtual bool getCollapsed() const;
  109.     virtual const DOMNode* getCommonAncestorContainer() const;
  110.     //setter functions
  111.     virtual void setStart(const DOMNode *parent, XMLSize_t offset);
  112.     virtual void setEnd(const DOMNode *parent, XMLSize_t offset);
  113.     virtual void setStartBefore(const DOMNode *refNode);
  114.     virtual void setStartAfter(const DOMNode *refNode);
  115.     virtual void setEndBefore(const DOMNode *refNode);
  116.     virtual void setEndAfter(const DOMNode *refNode);
  117.     //misc functions
  118.     virtual void collapse(bool toStart);
  119.     virtual void selectNode(const DOMNode *node);
  120.     virtual void selectNodeContents(const DOMNode *node);
  121.     //Functions related to comparing range Boundrary-Points
  122.     virtual short compareBoundaryPoints(CompareHow how, const DOMRange* range) const;
  123.     virtual void deleteContents();
  124.     virtual DOMDocumentFragment* extractContents();
  125.     virtual DOMDocumentFragment* cloneContents() const;
  126.     virtual void insertNode(DOMNode* node);
  127.     //Misc functions
  128.     virtual void surroundContents(DOMNode *node);
  129.     virtual DOMRange* cloneRange() const;
  130.     virtual const XMLCh* toString() const;
  131.     virtual void detach();
  132.     virtual void release();
  133.     //getter functions
  134.     DOMDocument*         getDocument();
  135.     // functions to inform all existing valid ranges about a change
  136.     void updateSplitInfo(DOMNode* oldNode, DOMNode* startNode, XMLSize_t offset);
  137.     void updateRangeForInsertedNode(DOMNode* node);
  138.     void receiveReplacedText(DOMNode* node);
  139.     void updateRangeForDeletedText(DOMNode* node, XMLSize_t offset, int count);
  140.     void updateRangeForInsertedText(DOMNode* node, XMLSize_t offset, int count);
  141.     void updateRangeForDeletedNode(DOMNode* node);
  142. private:
  143.     //setter functions
  144.     void        setStartContainer(const DOMNode* node);
  145.     void        setStartOffset(XMLSize_t offset) ;
  146.     void        setEndContainer(const DOMNode* node);
  147.     void        setEndOffset(XMLSize_t offset) ;
  148.     //misc functions
  149.     void        validateNode(const DOMNode* node) const;
  150.     bool        isValidAncestorType(const DOMNode* node) const;
  151.     bool        hasLegalRootContainer(const DOMNode* node) const;
  152.     bool        isLegalContainedNode(const DOMNode* node ) const;
  153.     void        checkIndex(const DOMNode* node, XMLSize_t offset) const;
  154.     static bool isAncestorOf(const DOMNode* a, const DOMNode* b);
  155.     XMLSize_t   indexOf(const DOMNode* child, const DOMNode* parent) const;
  156.     const DOMNode*       commonAncestorOf(const DOMNode* pointA, const DOMNode* pointB) const;
  157.     DOMNode*             nextNode(const DOMNode* node, bool visitChildren) const;
  158.     DOMDocumentFragment* traverseContents(TraversalType type);
  159.     void                  checkReadOnly(DOMNode* start, DOMNode* end,
  160.                                   XMLSize_t starOffset, XMLSize_t endOffset);
  161.     void                  recurseTreeAndCheck(DOMNode* start, DOMNode* end);
  162.     DOMNode*             removeChild(DOMNode* parent, DOMNode* child);
  163.     DOMDocumentFragment* traverseSameContainer( int how );
  164.     DOMDocumentFragment* traverseCommonStartContainer( DOMNode *endAncestor, int how );
  165.     DOMDocumentFragment* traverseCommonEndContainer( DOMNode *startAncestor, int how );
  166.     DOMDocumentFragment* traverseCommonAncestors( DOMNode *startAncestor, DOMNode *endAncestor, int how );
  167.     DOMNode*    traverseRightBoundary( DOMNode *root, int how );
  168.     DOMNode*    traverseLeftBoundary( DOMNode *root, int how );
  169.     DOMNode*    traverseNode( DOMNode *n, bool isFullySelected, bool isLeft, int how );
  170.     DOMNode*    traverseFullySelected( DOMNode *n, int how );
  171.     DOMNode*    traversePartiallySelected( DOMNode *n, int how );
  172.     DOMNode*    traverseTextNode( DOMNode *n, bool isLeft, int how );
  173.     DOMNode*    getSelectedNode( DOMNode *container, int offset );
  174. };
  175. XERCES_CPP_NAMESPACE_END
  176. #endif