Lines Matching refs:Node
70 inline Range::Range(PassRefPtr<Document> ownerDocument, PassRefPtr<Node> startContainer, int startOffset, PassRefPtr<Node> endContainer, int endOffset)
90 PassRefPtr<Range> Range::create(PassRefPtr<Document> ownerDocument, PassRefPtr<Node> startContainer, int startOffset, PassRefPtr<Node> endContainer, int endOffset)
98 return adoptRef(new Range(ownerDocument, start.node(), start.deprecatedEditingOffset(), end.node(), end.deprecatedEditingOffset()));
111 Node* Range::startContainer(ExceptionCode& ec) const
131 Node* Range::endContainer(ExceptionCode& ec) const
151 Node* Range::commonAncestorContainer(ExceptionCode& ec) const
161 Node* Range::commonAncestorContainer(Node* containerA, Node* containerB)
163 for (Node* parentA = containerA; parentA; parentA = parentA->parentNode()) {
164 for (Node* parentB = containerB; parentB; parentB = parentB->parentNode()) {
182 void Range::setStart(PassRefPtr<Node> refNode, int offset, ExceptionCode& ec)
200 Node* childNode = checkNodeWOffset(refNode.get(), offset, ec);
207 Node* endRootContainer = m_end.container();
210 Node* startRootContainer = m_start.container();
220 void Range::setEnd(PassRefPtr<Node> refNode, int offset, ExceptionCode& ec)
238 Node* childNode = checkNodeWOffset(refNode.get(), offset, ec);
245 Node* endRootContainer = m_end.container();
248 Node* startRootContainer = m_start.container();
271 bool Range::isPointInRange(Node* refNode, int offset, ExceptionCode& ec)
302 short Range::comparePoint(Node* refNode, int offset, ExceptionCode& ec) const
306 // refNode node and an offset within the node is before, same as, or after the range respectively.
340 Range::CompareResults Range::compareNode(Node* refNode, ExceptionCode& ec) const
343 // This method returns 0, 1, 2, or 3 based on if the node is before, after,
366 Node* parentNode = refNode->parentNode();
370 // if the node is the top document we should return NODE_BEFORE_AND_AFTER
400 Node* thisCont = commonAncestorContainer(ec);
403 Node* sourceCont = sourceRange->commonAncestorContainer(ec);
412 Node* thisTop = thisCont;
413 Node* sourceTop = sourceCont;
438 short Range::compareBoundaryPoints(Node* containerA, int offsetA, Node* containerB, int offsetB)
460 // case 2: node C (container B or an ancestor) is a child node of A
461 Node* c = containerB;
466 Node* n = containerA->firstChild();
478 // case 3: node C (container A or an ancestor) is a child node of B
484 Node* n = containerB->firstChild();
498 Node* commonAncestor = commonAncestorContainer(containerA, containerB);
501 Node* childA = containerA;
506 Node* childB = containerB;
515 Node* n = commonAncestor->firstChild();
548 bool Range::intersectsNode(Node* refNode, ExceptionCode& ec)
551 // Returns a bool if the node intersects the range.
565 Node* parentNode = refNode->parentNode();
569 // if the node is the top document we should return NODE_BEFORE_AND_AFTER
601 Node* commonRoot = commonAncestorContainer(ec);
606 // what is the highest node that partially selects the start of the range?
607 Node* partialStart = 0;
614 // what is the highest node that partially selects the end of the range?
615 Node* partialEnd = 0;
625 Node::NodeType startNodeType = m_start.container()->nodeType();
626 if (startNodeType == Node::TEXT_NODE || startNodeType == Node::CDATA_SECTION_NODE || startNodeType == Node::COMMENT_NODE) {
635 } else if (startNodeType == Node::PROCESSING_INSTRUCTION_NODE) {
648 Node* n = m_start.container()->firstChild();
654 Node* next = n->nextSibling();
685 RefPtr<Node> leftContents;
689 Node::NodeType startNodeType = m_start.container()->nodeType();
690 if (startNodeType == Node::TEXT_NODE || startNodeType == Node::CDATA_SECTION_NODE || startNodeType == Node::COMMENT_NODE) {
699 } else if (startNodeType == Node::PROCESSING_INSTRUCTION_NODE) {
713 Node* n = m_start.container()->firstChild();
717 Node* next = n->nextSibling();
728 Node* leftParent = m_start.container()->parentNode();
729 Node* n = m_start.container()->nextSibling();
732 RefPtr<Node> leftContentsParent = leftParent->cloneNode(false);
737 Node* next;
751 RefPtr<Node> rightContents;
755 Node::NodeType endNodeType = m_end.container()->nodeType();
756 if (endNodeType == Node::TEXT_NODE || endNodeType == Node::CDATA_SECTION_NODE || endNodeType == Node::COMMENT_NODE) {
764 } else if (endNodeType == Node::PROCESSING_INSTRUCTION_NODE) {
777 Node* n = m_end.container()->firstChild();
780 Node* next = n->nextSibling();
785 Node* prev;
798 Node* rightParent = m_end.container()->parentNode();
799 Node* n = m_end.container()->previousSibling();
802 RefPtr<Node> rightContentsParent = rightParent->cloneNode(false);
806 Node* prev;
822 Node* processStart; // child of commonRoot
833 Node* processEnd; // child of commonRoot
844 // Collapse the range, making sure that the result is not within a node that was partially selected.
861 Node* next;
862 Node* n;
900 void Range::insertNode(PassRefPtr<Node> prpNewNode, ExceptionCode& ec)
902 RefPtr<Node> newNode = prpNewNode;
933 // an extra one here - if a text node is going to split, it must have a parent to insert into
940 // In the case where the container is a text node, we check against the container's parent, because
942 Node* checkAgainst;
948 Node::NodeType newNodeType = newNode->nodeType();
950 if (newNodeType == Node::DOCUMENT_FRAGMENT_NODE) {
951 // check each child node, not the DocumentFragment itself
953 for (Node* c = newNode->firstChild(); c; c = c->nextSibling()) {
968 for (Node* n = m_start.container(); n; n = n->parentNode()) {
975 // INVALID_NODE_TYPE_ERR: Raised if newNode is an Attr, Entity, Notation, or Document node.
976 if (newNodeType == Node::ATTRIBUTE_NODE || newNodeType == Node::ENTITY_NODE
977 || newNodeType == Node::NOTATION_NODE || newNodeType == Node::DOCUMENT_NODE) {
996 RefPtr<Node> lastChild;
998 lastChild = (newNodeType == Node::DOCUMENT_FRAGMENT_NODE) ? newNode->lastChild() : newNode;
1021 Node* pastLast = pastLastNode();
1022 for (Node* n = firstNode(); n != pastLast; n = n->traverseNextNode()) {
1023 if (n->nodeType() == Node::TEXT_NODE || n->nodeType() == Node::CDATA_SECTION_NODE) {
1059 Node* element = m_start.container()->isElementNode() ? m_start.container() : m_start.container()->parentNode();
1089 Node* Range::checkNodeWOffset(Node* n, int offset, ExceptionCode& ec) const
1092 case Node::DOCUMENT_TYPE_NODE:
1093 case Node::ENTITY_NODE:
1094 case Node::NOTATION_NODE:
1097 case Node::CDATA_SECTION_NODE:
1098 case Node::COMMENT_NODE:
1099 case Node::TEXT_NODE:
1103 case Node::PROCESSING_INSTRUCTION_NODE:
1107 case Node::ATTRIBUTE_NODE:
1108 case Node::DOCUMENT_FRAGMENT_NODE:
1109 case Node::DOCUMENT_NODE:
1110 case Node::ELEMENT_NODE:
1111 case Node::ENTITY_REFERENCE_NODE:
1112 case Node::XPATH_NAMESPACE_NODE: {
1115 Node* childBefore = n->childNode(offset - 1);
1125 void Range::checkNodeBA(Node* n, ExceptionCode& ec) const
1128 // Attr, Document or DocumentFragment node or part of a shadow DOM tree
1129 // or if refNode is a Document, DocumentFragment, Attr, Entity, or Notation node.
1132 case Node::ATTRIBUTE_NODE:
1133 case Node::DOCUMENT_FRAGMENT_NODE:
1134 case Node::DOCUMENT_NODE:
1135 case Node::ENTITY_NODE:
1136 case Node::NOTATION_NODE:
1139 case Node::CDATA_SECTION_NODE:
1140 case Node::COMMENT_NODE:
1141 case Node::DOCUMENT_TYPE_NODE:
1142 case Node::ELEMENT_NODE:
1143 case Node::ENTITY_REFERENCE_NODE:
1144 case Node::PROCESSING_INSTRUCTION_NODE:
1145 case Node::TEXT_NODE:
1146 case Node::XPATH_NAMESPACE_NODE:
1150 Node* root = n;
1151 while (Node* parent = root->parentNode())
1155 case Node::ATTRIBUTE_NODE:
1156 case Node::DOCUMENT_NODE:
1157 case Node::DOCUMENT_FRAGMENT_NODE:
1159 case Node::CDATA_SECTION_NODE:
1160 case Node::COMMENT_NODE:
1161 case Node::DOCUMENT_TYPE_NODE:
1162 case Node::ELEMENT_NODE:
1163 case Node::ENTITY_NODE:
1164 case Node::ENTITY_REFERENCE_NODE:
1165 case Node::NOTATION_NODE:
1166 case Node::PROCESSING_INSTRUCTION_NODE:
1167 case Node::TEXT_NODE:
1168 case Node::XPATH_NAMESPACE_NODE:
1186 void Range::setStartAfter(Node* refNode, ExceptionCode& ec)
1211 void Range::setEndBefore(Node* refNode, ExceptionCode& ec)
1236 void Range::setEndAfter(Node* refNode, ExceptionCode& ec)
1262 void Range::selectNode(Node* refNode, ExceptionCode& ec)
1275 // DocumentType node or if refNode is a Document, DocumentFragment, Attr, Entity, or Notation
1276 // node.
1277 for (Node* anc = refNode->parentNode(); anc; anc = anc->parentNode()) {
1279 case Node::ATTRIBUTE_NODE:
1280 case Node::CDATA_SECTION_NODE:
1281 case Node::COMMENT_NODE:
1282 case Node::DOCUMENT_FRAGMENT_NODE:
1283 case Node::DOCUMENT_NODE:
1284 case Node::ELEMENT_NODE:
1285 case Node::ENTITY_REFERENCE_NODE:
1286 case Node::PROCESSING_INSTRUCTION_NODE:
1287 case Node::TEXT_NODE:
1288 case Node::XPATH_NAMESPACE_NODE:
1290 case Node::DOCUMENT_TYPE_NODE:
1291 case Node::ENTITY_NODE:
1292 case Node::NOTATION_NODE:
1299 case Node::CDATA_SECTION_NODE:
1300 case Node::COMMENT_NODE:
1301 case Node::DOCUMENT_TYPE_NODE:
1302 case Node::ELEMENT_NODE:
1303 case Node::ENTITY_REFERENCE_NODE:
1304 case Node::PROCESSING_INSTRUCTION_NODE:
1305 case Node::TEXT_NODE:
1306 case Node::XPATH_NAMESPACE_NODE:
1308 case Node::ATTRIBUTE_NODE:
1309 case Node::DOCUMENT_FRAGMENT_NODE:
1310 case Node::DOCUMENT_NODE:
1311 case Node::ENTITY_NODE:
1312 case Node::NOTATION_NODE:
1324 void Range::selectNodeContents(Node* refNode, ExceptionCode& ec)
1337 // or DocumentType node.
1338 for (Node* n = refNode; n; n = n->parentNode()) {
1340 case Node::ATTRIBUTE_NODE:
1341 case Node::CDATA_SECTION_NODE:
1342 case Node::COMMENT_NODE:
1343 case Node::DOCUMENT_FRAGMENT_NODE:
1344 case Node::DOCUMENT_NODE:
1345 case Node::ELEMENT_NODE:
1346 case Node::ENTITY_REFERENCE_NODE:
1347 case Node::PROCESSING_INSTRUCTION_NODE:
1348 case Node::TEXT_NODE:
1349 case Node::XPATH_NAMESPACE_NODE:
1351 case Node::DOCUMENT_TYPE_NODE:
1352 case Node::ENTITY_NODE:
1353 case Node::NOTATION_NODE:
1363 void Range::surroundContents(PassRefPtr<Node> passNewParent, ExceptionCode& ec)
1365 RefPtr<Node> newParent = passNewParent;
1377 // INVALID_NODE_TYPE_ERR: Raised if node is an Attr, Entity, DocumentType, Notation,
1378 // Document, or DocumentFragment node.
1380 case Node::ATTRIBUTE_NODE:
1381 case Node::DOCUMENT_FRAGMENT_NODE:
1382 case Node::DOCUMENT_NODE:
1383 case Node::DOCUMENT_TYPE_NODE:
1384 case Node::ENTITY_NODE:
1385 case Node::NOTATION_NODE:
1388 case Node::CDATA_SECTION_NODE:
1389 case Node::COMMENT_NODE:
1390 case Node::ELEMENT_NODE:
1391 case Node::ENTITY_REFERENCE_NODE:
1392 case Node::PROCESSING_INSTRUCTION_NODE:
1393 case Node::TEXT_NODE:
1394 case Node::XPATH_NAMESPACE_NODE:
1413 Node* parentOfNewParent = m_start.container();
1415 // If m_start.container() is a character data node, it will be split and it will be its parent that will
1430 // FIXME: Do we need a check if the node would end up with a child node of a type not
1431 // allowed by the type of node?
1433 // BAD_BOUNDARYPOINTS_ERR: Raised if the Range partially selects a non-Text node.
1434 Node* startNonTextContainer = m_start.container();
1435 if (startNonTextContainer->nodeType() == Node::TEXT_NODE)
1437 Node* endNonTextContainer = m_end.container();
1438 if (endNonTextContainer->nodeType() == Node::TEXT_NODE)
1446 while (Node* n = newParent->firstChild()) {
1463 void Range::setStartBefore(Node* refNode, ExceptionCode& ec)
1499 Node* pastLast = pastLastNode();
1500 for (Node* n = firstNode(); n != pastLast; n = n->traverseNextNode()) {
1505 if (n->nodeType() == Node::DOCUMENT_TYPE_NODE) {
1519 for (Node* n = m_start.container(); n; n = n->parentNode()) {
1523 for (Node* n = m_end.container(); n; n = n->parentNode()) {
1530 Node* Range::firstNode() const
1536 if (Node* child = m_start.container()->childNode(m_start.offset()))
1564 // otherwise, make sure to be at the start of the first selected node,
1565 // instead of possibly at the end of the last node before the selection
1569 Node* Range::shadowTreeRootNode() const
1574 Node* Range::pastLastNode() const
1580 if (Node* child = m_end.container()->childNode(m_end.offset()))
1598 Node* startContainer = m_start.container();
1599 Node* endContainer = m_end.container();
1604 Node* stopNode = pastLastNode();
1605 for (Node* node = firstNode(); node != stopNode; node = node->traverseNextNode()) {
1606 RenderObject* r = node->renderer();
1610 int startOffset = node == startContainer ? m_start.offset() : 0;
1611 int endOffset = node == endContainer ? m_end.offset() : numeric_limits<int>::max();
1618 Node* startContainer = m_start.container();
1619 Node* endContainer = m_end.container();
1624 Node* stopNode = pastLastNode();
1625 for (Node* node = firstNode(); node != stopNode; node = node->traverseNextNode()) {
1626 RenderObject* r = node->renderer();
1630 int startOffset = node == startContainer ? m_start.offset() : 0;
1631 int endOffset = node == endContainer ? m_end.offset() : numeric_limits<int>::max();
1675 PassRefPtr<Range> rangeOfContents(Node* node)
1677 ASSERT(node);
1678 RefPtr<Range> range = Range::create(node->document());
1680 range->selectNodeContents(node, exception);
1719 static inline void boundaryNodeWillBeRemoved(RangeBoundaryPoint& boundary, Node* nodeToBeRemoved)
1726 for (Node* n = boundary.container(); n; n = n->parentNode()) {
1734 void Range::nodeWillBeRemoved(Node* node)
1736 ASSERT(node);
1737 ASSERT(node->document() == m_ownerDocument);
1738 ASSERT(node != m_ownerDocument);
1739 ASSERT(node->parentNode());
1740 boundaryNodeWillBeRemoved(m_start, node);
1741 boundaryNodeWillBeRemoved(m_end, node);
1744 static inline void boundaryTextInserted(RangeBoundaryPoint& boundary, Node* text, unsigned offset, unsigned length)
1754 void Range::textInserted(Node* text, unsigned offset, unsigned length)
1762 static inline void boundaryTextRemoved(RangeBoundaryPoint& boundary, Node* text, unsigned offset, unsigned length)
1775 void Range::textRemoved(Node* text, unsigned offset, unsigned length)
1785 if (boundary.container() == oldNode.node())
1786 boundary.set(oldNode.node()->previousSibling(), boundary.offset() + offset, 0);
1787 else if (boundary.container() == oldNode.node()->parentNode() && boundary.offset() == oldNode.index())
1788 boundary.set(oldNode.node()->previousSibling(), offset, 0);
1793 ASSERT(oldNode.node());
1794 ASSERT(oldNode.node()->document() == m_ownerDocument);
1795 ASSERT(oldNode.node()->parentNode());
1796 ASSERT(oldNode.node()->isTextNode());
1797 ASSERT(oldNode.node()->previousSibling());
1798 ASSERT(oldNode.node()->previousSibling()->isTextNode());
1895 Node* startContainer = m_start.container();
1896 Node* endContainer = m_end.container();
1897 Node* stopNode = pastLastNode();
1899 HashSet<Node*> nodeSet;
1900 for (Node* node = firstNode(); node != stopNode; node = node->traverseNextNode()) {
1901 if (node->isElementNode())
1902 nodeSet.add(node);
1905 for (Node* node = firstNode(); node != stopNode; node = node->traverseNextNode()) {
1906 if (node->isElementNode()) {
1907 if (!nodeSet.contains(node->parentNode())) {
1908 if (RenderBoxModelObject* renderBoxModelObject = static_cast<Element*>(node)->renderBoxModelObject()) {
1916 } else if (node->isTextNode()) {
1917 if (RenderObject* renderer = static_cast<Text*>(node)->renderer()) {
1919 int startOffset = (node == startContainer) ? m_start.offset() : 0;
1920 int endOffset = (node == endContainer) ? m_end.offset() : INT_MAX;
1941 start.node()->showTreeAndMark(start.node(), "S", end.node(), "E");
