void Range::surroundContents( const Node &newParent ) { checkCommon(); if( newParent.isNull() ) return; Node start = startContainer(); if( newParent.ownerDocument() != start.ownerDocument() ) throw DOMException( DOMException::WRONG_DOCUMENT_ERR ); if( newParent.nodeType() == Node::ATTRIBUTE_NODE || newParent.nodeType() == Node::ENTITY_NODE || newParent.nodeType() == Node::NOTATION_NODE || newParent.nodeType() == Node::DOCUMENT_TYPE_NODE || newParent.nodeType() == Node::DOCUMENT_NODE || newParent.nodeType() == Node::DOCUMENT_FRAGMENT_NODE) throw RangeException( RangeException::INVALID_NODE_TYPE_ERR ); // revisit: if you set a range without optimizing it (trimming) the following exception might be // thrown incorrectly Node realStart = (start.nodeType() == Node::TEXT_NODE)? start.parentNode() : start; Node end = endContainer(); Node realEnd = (end.nodeType() == Node::TEXT_NODE)? end.parentNode() : end; if( realStart != realEnd ) throw RangeException( RangeException::BAD_BOUNDARYPOINTS_ERR ); DocumentFragment fragment = extractContents(); insertNode( newParent ); // BIC: to avoid this const_cast newParent shouldn't be const //(const_cast<Node>(newParent)).appendChild( fragment ); ((Node)(newParent)).appendChild( fragment ); selectNode( newParent ); }
void StyleElement::process(Element* e) { if (!e || !e->inDocument()) return; unsigned resultLength = 0; for (Node* c = e->firstChild(); c; c = c->nextSibling()) { Node::NodeType nodeType = c->nodeType(); if (nodeType == Node::TEXT_NODE || nodeType == Node::CDATA_SECTION_NODE || nodeType == Node::COMMENT_NODE) resultLength += c->nodeValue().length(); } UChar* text; String sheetText = String::createUninitialized(resultLength, text); UChar* p = text; for (Node* c = e->firstChild(); c; c = c->nextSibling()) { Node::NodeType nodeType = c->nodeType(); if (nodeType == Node::TEXT_NODE || nodeType == Node::CDATA_SECTION_NODE || nodeType == Node::COMMENT_NODE) { String nodeValue = c->nodeValue(); unsigned nodeLength = nodeValue.length(); memcpy(p, nodeValue.characters(), nodeLength * sizeof(UChar)); p += nodeLength; } } ASSERT(p == text + resultLength); createSheet(e, sheetText); }
NodeList Element::getElementsByTagName (const DOMString& name) { NodeList elements; for (size_t i = 0; i < _children.length(); i++) { Node* node = _children.item(i); if (node->nodeType() == Node::ELEMENT_NODE) { if (((Element*)node)->tagName() == Utils::toUpper(name)) { elements.insert(node); } } } for (size_t i = 0; i < _children.length(); i++) { Node* node = _children.item(i); if (node->nodeType() == Node::ELEMENT_NODE) { NodeList subElements = ((Element*)node)->getElementsByTagName(name); for (size_t h = 0; h < subElements.length(); h++) { elements.insert(subElements.item(h)); } } } return elements; }
void HTMLTitleElement::childrenChanged(bool changedByParser, Node* beforeChange, Node* afterChange, int childCountDelta) { m_title = ""; for (Node* c = firstChild(); c != 0; c = c->nextSibling()) if (c->nodeType() == TEXT_NODE || c->nodeType() == CDATA_SECTION_NODE) m_title += c->nodeValue(); if (inDocument()) document()->setTitle(m_title, this); HTMLElement::childrenChanged(changedByParser, beforeChange, afterChange, childCountDelta); }
void HTMLTitleElement::childrenChanged() { HTMLElement::childrenChanged(); m_title = ""; for (Node* c = firstChild(); c != 0; c = c->nextSibling()) if (c->nodeType() == TEXT_NODE || c->nodeType() == CDATA_SECTION_NODE) m_title += c->nodeValue(); if (inDocument()) document()->setTitle(m_title, this); }
Value LocationPath::evaluate() const { EvaluationContext& evaluationContext = Expression::evaluationContext(); EvaluationContext backupContext = evaluationContext; // http://www.w3.org/TR/xpath/ // Section 2, Location Paths: // "/ selects the document root (which is always the parent of the document element)" // "A / by itself selects the root node of the document containing the context node." // In the case of a tree that is detached from the document, we violate // the spec and treat / as the root node of the detached tree. // This is for compatibility with Firefox, and also seems like a more // logical treatment of where you would expect the "root" to be. Node* context = evaluationContext.node.get(); if (m_absolute && context->nodeType() != Node::DOCUMENT_NODE) { if (context->inDocument()) context = context->ownerDocument(); else context = context->highestAncestor(); } NodeSet nodes; nodes.append(context); evaluate(nodes); evaluationContext = backupContext; return Value(nodes, Value::adopt); }
void MarkupAccumulator::appendStartMarkup(StringBuilder& result, Node& node, Namespaces* namespaces) { switch (node.nodeType()) { case Node::TEXT_NODE: appendText(result, toText(node)); break; case Node::COMMENT_NODE: appendComment(result, toComment(node).data()); break; case Node::DOCUMENT_NODE: appendXMLDeclaration(result, toDocument(node)); break; case Node::DOCUMENT_FRAGMENT_NODE: break; case Node::DOCUMENT_TYPE_NODE: appendDocumentType(result, toDocumentType(node)); break; case Node::PROCESSING_INSTRUCTION_NODE: appendProcessingInstruction(result, toProcessingInstruction(node).target(), toProcessingInstruction(node).data()); break; case Node::ELEMENT_NODE: appendElement(result, toElement(node), namespaces); break; case Node::CDATA_SECTION_NODE: appendCDATASection(result, toCDATASection(node).data()); break; case Node::ATTRIBUTE_NODE: ASSERT_NOT_REACHED(); break; } }
String OptionElement::collectOptionInnerText(const Element* element) { String text; Node* n = element->firstChild(); while (n) { if (n->nodeType() == Node::TEXT_NODE || n->nodeType() == Node::CDATA_SECTION_NODE) text += n->nodeValue(); // skip script content if (n->isElementNode() && toScriptElement(static_cast<Element*>(n))) n = n->traverseNextSibling(element); else n = n->traverseNextNode(element); } return text; }
void Range::insertNode( const Node &newNode ) { checkCommon(); if( newNode.nodeType() == Node::ATTRIBUTE_NODE || newNode.nodeType() == Node::ENTITY_NODE || newNode.nodeType() == Node::NOTATION_NODE || newNode.nodeType() == Node::DOCUMENT_NODE || newNode.nodeType() == Node::DOCUMENT_FRAGMENT_NODE) throw RangeException( RangeException::INVALID_NODE_TYPE_ERR); if( newNode.ownerDocument() != startContainer().ownerDocument() ) throw DOMException( DOMException::WRONG_DOCUMENT_ERR ); impl->insertNode(newNode); }
Element* Element::getChildElementNS(const XMLString& namespaceURI, const XMLString& localName) const { Node* pNode = firstChild(); while (pNode && !(pNode->nodeType() == Node::ELEMENT_NODE && pNode->namespaceURI() == namespaceURI && pNode->localName() == localName)) pNode = pNode->nextSibling(); return static_cast<Element*>(pNode); }
bool DOMPatchSupport::innerPatchNode(Digest* oldDigest, Digest* newDigest, ExceptionState& exceptionState) { if (oldDigest->m_sha1 == newDigest->m_sha1) return true; Node* oldNode = oldDigest->m_node; Node* newNode = newDigest->m_node; if (newNode->nodeType() != oldNode->nodeType() || newNode->nodeName() != oldNode->nodeName()) return m_domEditor->replaceChild(oldNode->parentNode(), newNode, oldNode, exceptionState); if (oldNode->nodeValue() != newNode->nodeValue()) { if (!m_domEditor->setNodeValue(oldNode, newNode->nodeValue(), exceptionState)) return false; } if (!oldNode->isElementNode()) return true; // Patch attributes Element* oldElement = toElement(oldNode); Element* newElement = toElement(newNode); if (oldDigest->m_attrsSHA1 != newDigest->m_attrsSHA1) { // FIXME: Create a function in Element for removing all properties. Take in account whether did/willModifyAttribute are important. if (oldElement->hasAttributesWithoutUpdate()) { while (oldElement->attributeCount()) { const Attribute& attribute = oldElement->attributeAt(0); if (!m_domEditor->removeAttribute(oldElement, attribute.localName(), exceptionState)) return false; } } // FIXME: Create a function in Element for copying properties. cloneDataFromElement() is close but not enough for this case. if (newElement->hasAttributesWithoutUpdate()) { AttributeCollection attributes = newElement->attributes(); AttributeCollection::const_iterator end = attributes.end(); for (AttributeCollection::const_iterator it = attributes.begin(); it != end; ++it) { if (!m_domEditor->setAttribute(oldElement, it->name().localName(), it->value(), exceptionState)) return false; } } } bool result = innerPatchChildren(oldElement, oldDigest->m_children, newDigest->m_children, exceptionState); m_unusedNodesMap.remove(newDigest->m_sha1); return result; }
bool DOMPatchSupport::innerPatchNode(Digest* oldDigest, Digest* newDigest, ExceptionCode& ec) { if (oldDigest->m_sha1 == newDigest->m_sha1) return true; Node* oldNode = oldDigest->m_node; Node* newNode = newDigest->m_node; if (newNode->nodeType() != oldNode->nodeType() || newNode->nodeName() != oldNode->nodeName()) return m_domEditor->replaceChild(oldNode->parentNode(), newNode, oldNode, ec); if (oldNode->nodeValue() != newNode->nodeValue()) { if (!m_domEditor->setNodeValue(oldNode, newNode->nodeValue(), ec)) return false; } if (oldNode->nodeType() != Node::ELEMENT_NODE) return true; // Patch attributes Element* oldElement = static_cast<Element*>(oldNode); Element* newElement = static_cast<Element*>(newNode); if (oldDigest->m_attrsSHA1 != newDigest->m_attrsSHA1) { // FIXME: Create a function in Element for removing all properties. Take in account whether did/willModifyAttribute are important. if (oldElement->hasAttributesWithoutUpdate()) { while (oldElement->attributeCount()) { Attribute* attr = oldElement->attributeItem(0); if (!m_domEditor->removeAttribute(oldElement, attr->localName(), ec)) return false; } } // FIXME: Create a function in Element for copying properties. setAttributesFromElement() is close but not enough for this case. if (newElement->hasAttributesWithoutUpdate()) { size_t numAttrs = newElement->attributeCount(); for (size_t i = 0; i < numAttrs; ++i) { const Attribute* attribute = newElement->attributeItem(i); if (!m_domEditor->setAttribute(oldElement, attribute->name().localName(), attribute->value(), ec)) return false; } } } bool result = innerPatchChildren(oldElement, oldDigest->m_children, newDigest->m_children, ec); m_unusedNodesMap.remove(newDigest->m_sha1); return result; }
Node* DTDMap::getNamedItem(const XMLString& name) const { Node* pCur = _pDocumentType->firstChild(); while (pCur) { if (pCur->nodeType() == _type && pCur->nodeName() == name) return pCur; pCur = pCur->nextSibling(); } return pCur; }
String createFullMarkup(const Node& node) { // FIXME: This is never "for interchange". Is that right? String markupString = createMarkup(node, IncludeNode, 0); Node::NodeType nodeType = node.nodeType(); if (nodeType != Node::DOCUMENT_NODE && nodeType != Node::DOCUMENT_TYPE_NODE) markupString = documentTypeString(node.document()) + markupString; return markupString; }
unsigned long DTDMap::length() const { unsigned long n = 0; Node* pCur = _pDocumentType->firstChild(); while (pCur) { if (pCur->nodeType() == _type) ++n; pCur = pCur->nextSibling(); } return n; }
static inline bool isChildTypeAllowed(ContainerNode* newParent, Node* child) { if (!child->isDocumentFragment()) return newParent->childTypeAllowed(child->nodeType()); for (Node* node = child->firstChild(); node; node = node->nextSibling()) { if (!newParent->childTypeAllowed(node->nodeType())) return false; } return true; }
std::string Node::getRawData(bool includeName) const { std::string s, v = data(); bool hasV = find_if(v.begin(), v.end(), std::not1(std::ptr_fun(isspace))) != v.end(); if (includeName) { s += "<" + name(); unsigned int attCnt = 0; for( unsigned int i = 0; i < getNodeCount(); ++i ) { Node *node = getNode( i ); if( node->nodeType() == Attribute) { s += " " + node->name() + "='"+ node->asString() + "'"; attCnt++; } } if (attCnt == getNodeCount()) // have not elements { if (!hasV) s += "/>"; else s += ">" + v + "</" + name() + ">\r\n"; return s; } else { s += ">\r\n"; if (hasV) s += v + "\r\n"; } } for( unsigned int i = 0; i < getNodeCount(); ++i ) { Node *node = getNode( i ); if( node->nodeType() == Element) s += node->getRawData(); } if (includeName) s += "</" + name() + ">\r\n"; return s; }
void Element::normalize() { Node* pCur = firstChild(); while (pCur) { if (pCur->nodeType() == Node::ELEMENT_NODE) { pCur->normalize(); } else if (pCur->nodeType() == Node::TEXT_NODE) { Node* pNext = pCur->nextSibling(); while (pNext && pNext->nodeType() == Node::TEXT_NODE) { static_cast<Text*>(pCur)->appendData(pNext->nodeValue()); removeChild(pNext); pNext = pCur->nextSibling(); } } pCur = pCur->nextSibling(); } }
static Node * getRootNode(Document * document) { NodeListPtr children = document->childNodes(); for (size_t i = 0; i < children->length(); ++i) { Node * child = children->item(i); /// Besides the root element there can be comment nodes on the top level. /// Skip them. if (child->nodeType() == Node::ELEMENT_NODE) return child; } throw Poco::Exception("No root node in document"); }
bool Node::lookupAttribute( const std::string &name, std::string &data ) const { for( unsigned int i = 0; i < getNodeCount(); ++i ) { Node *node = getNode( i ); if( node->nodeType() != Attribute || node->name() != name ) continue; data = node->data(); return true; } return false; }
static bool findNodesSurroundingContext(Document* document, RefPtr<Node>& nodeBeforeContext, RefPtr<Node>& nodeAfterContext) { for (Node* node = document->firstChild(); node; node = NodeTraversal::next(node)) { if (node->nodeType() == Node::COMMENT_NODE && static_cast<CharacterData*>(node)->data() == fragmentMarkerTag) { if (!nodeBeforeContext) nodeBeforeContext = node; else { nodeAfterContext = node; return true; } } } return false; }
bool InspectorStyleSheet::inlineStyleSheetText(String* result) const { if (!m_pageStyleSheet) return false; Node* ownerNode = m_pageStyleSheet->ownerNode(); if (!ownerNode || ownerNode->nodeType() != Node::ELEMENT_NODE) return false; Element* ownerElement = static_cast<Element*>(ownerNode); if (ownerElement->tagName().lower() != "style") return false; *result = ownerElement->innerText(); return true; }
void MarkupAccumulator::appendStartMarkup(StringBuilder& result, Node& node, Namespaces* namespaces) { switch (node.nodeType()) { case Node::TEXT_NODE: appendText(result, toText(node)); break; case Node::ELEMENT_NODE: appendElement(result, toElement(node), namespaces); break; default: m_formatter.appendStartMarkup(result, node, namespaces); break; } }
void ExtensionPointService::handleExtensions(Bundle::ConstPtr pBundle, std::istream& istr, GenericHandler handler, Direction dir) { Poco::XML::DOMParser parser; parser.setFeature(Poco::XML::XMLReader::FEATURE_NAMESPACES, false); parser.setFeature(Poco::XML::DOMParser::FEATURE_FILTER_WHITESPACE, true); Poco::XML::InputSource source(istr); AutoPtr<Document> pDoc(parser.parse(&source)); Node* pRoot = pDoc->firstChild(); while (pRoot && pRoot->nodeName() != EXTENSIONS_ELEM) { pRoot = pRoot->nextSibling(); } if (pRoot) { Node* pNode = (dir == DIR_FORWARD ? pRoot->firstChild() : pRoot->lastChild()); while (pNode) { if (pNode->nodeType() == Node::ELEMENT_NODE) { if (pNode->nodeName() == EXTENSION_ELEM) { Element* pElem = static_cast<Element*>(pNode); const std::string& id = pElem->getAttribute(POINT_ATTR); if (!id.empty()) { (this->*handler)(pBundle, id, pElem); } else { _logger.error(std::string("No point attribute found in extension element of bundle ") + pBundle->symbolicName()); } } else { _logger.warning(std::string("Unsupported element '") + pNode->nodeName() + "' found in " + EXTENSIONS_XML + " of bundle " + pBundle->symbolicName()); } } pNode = (dir == DIR_FORWARD ? pNode->nextSibling() : pNode->previousSibling()); } } else throw Poco::NotFoundException("No extensions element found"); }
void JSNode::setTextContent(JSC::ExecState* exec, JSC::JSValue value) { Node* imp = static_cast<Node*>(impl()); String nodeValue = valueToStringWithNullCheck(exec, value); if (imp->nodeType() == Node::ATTRIBUTE_NODE) { Element* ownerElement = static_cast<Attr*>(impl())->ownerElement(); if (ownerElement && !allowSettingSrcToJavascriptURL(exec, ownerElement, imp->nodeName(), nodeValue)) return; } ExceptionCode ec = 0; imp->setTextContent(nodeValue, ec); setDOMException(exec, ec); }
Node* DTDMap::item(unsigned long index) const { unsigned long n = 0; Node* pCur = _pDocumentType->firstChild(); while (pCur) { if (pCur->nodeType() == _type) { if (n == index) return pCur; ++n; } pCur = pCur->nextSibling(); } return pCur; }
JSValue JSNamedNodeMap::setNamedItemNS(ExecState* exec, const ArgList& args) { NamedNodeMap* imp = static_cast<NamedNodeMap*>(impl()); ExceptionCode ec = 0; Node* newNode = toNode(args.at(0)); if (newNode && newNode->nodeType() == Node::ATTRIBUTE_NODE && imp->element()) { if (!allowSettingSrcToJavascriptURL(exec, imp->element(), newNode->nodeName(), newNode->nodeValue())) return jsNull(); } JSValue result = toJS(exec, globalObject(), WTF::getPtr(imp->setNamedItemNS(newNode, ec))); setDOMException(exec, ec); return result; }
JSValue JSNode::appendChild(ExecState* exec, const ArgList& args) { Node* imp = static_cast<Node*>(impl()); if (imp->nodeType() == Node::ATTRIBUTE_NODE && isAttrFrameSrc(static_cast<Attr*>(impl())->ownerElement(), imp->nodeName())) { setDOMException(exec, NOT_SUPPORTED_ERR); return jsNull(); } ExceptionCode ec = 0; bool ok = imp->appendChild(toNode(args.at(0)), ec, true); setDOMException(exec, ec); if (ok) return args.at(0); return jsNull(); }
Node *ProjectTree::nodeForFile(const FileName &fileName) { Node *node = nullptr; for (const Project *project : SessionManager::projects()) { if (ProjectNode *projectNode = project->rootProjectNode()) { projectNode->forEachGenericNode([&](Node *n) { if (n->filePath() == fileName) { // prefer file nodes if (!node || (node->nodeType() != NodeType::File && n->nodeType() == NodeType::File)) node = n; } }); } } return node; }
String OptionElement::collectOptionInnerText(const Element* element) { /// M: @{ StringBuilder text; for (Node* node = element->firstChild(); node; ) { if (node->isTextNode() || node->nodeType() == Node::CDATA_SECTION_NODE) text.append(node->nodeValue()); // Text nodes inside script elements are not part of the option text. if (node->isElementNode() && toScriptLoaderIfPossible(toElement(node))) node = NodeTraversal::nextSkippingChildren(*node, element); else node = NodeTraversal::next(*node, element); } return text.toString(); /// @} }