/** * This file is part of the DOM implementation for KDE. * * Copyright (C) 1999 Lars Knoll (knoll@kde.org) * (C) 1999 Antti Koivisto (koivisto@kde.org) * (C) 2001 Peter Kelly (pmk@post.com) * (C) 2001 Dirk Mueller (mueller@kde.org) * (C) 2006 Allan Sandfeld Jensen (kde@carewolf.com) * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Library General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public License * along with this library; see the file COPYING.LIB. If not, write to * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, * Boston, MA 02110-1301, USA. */ //#define EVENT_DEBUG #include "dom/dom_exception.h" #include "dom/dom_node.h" #include "dom/html_image.h" #include "xml/dom_textimpl.h" #include "xml/dom_docimpl.h" #include "xml/dom2_eventsimpl.h" #include "xml/dom_elementimpl.h" #include "xml/dom_restyler.h" #include "html/dtd.h" #include "html/htmlparser.h" #include "html/html_imageimpl.h" #include "rendering/render_canvas.h" #include "misc/htmlhashes.h" #include "css/css_valueimpl.h" #include "css/css_stylesheetimpl.h" #include "css/cssstyleselector.h" #include "css/cssvalues.h" #include "css/cssproperties.h" #include "xml/dom_xmlimpl.h" #include <tqtextstream.h> #include <kdebug.h> #include <stdlib.h> // ### support default attributes // ### dispatch mutation events // ### check for INVALID_CHARACTER_ERR where appropriate using namespace DOM; using namespace tdehtml; AttrImpl::AttrImpl(ElementImpl* element, DocumentImpl* docPtr, NodeImpl::Id attrId, DOMStringImpl *value, DOMStringImpl *prefix) : NodeBaseImpl(docPtr), m_element(element), m_attrId(attrId) { m_value = value; m_value->ref(); m_prefix = prefix; if (m_prefix) m_prefix->ref(); m_specified = true; // we don't yet support default attributes } AttrImpl::~AttrImpl() { m_value->deref(); if (m_prefix) m_prefix->deref(); } DOMString AttrImpl::nodeName() const { return name(); } unsigned short AttrImpl::nodeType() const { return Node::ATTRIBUTE_NODE; } DOMString AttrImpl::prefix() const { return m_prefix; } void AttrImpl::setPrefix(const DOMString &_prefix, int &exceptioncode ) { checkSetPrefix(_prefix, exceptioncode); if (exceptioncode) return; if (m_prefix == _prefix.implementation()) return; if (m_prefix) m_prefix->deref(); m_prefix = _prefix.implementation(); if (m_prefix) m_prefix->ref(); } DOMString AttrImpl::namespaceURI() const { if (m_htmlCompat) return DOMString(); return getDocument()->getName(NamespaceId, m_attrId >> 16); } DOMString AttrImpl::localName() const { if (m_htmlCompat) return DOMString(); return getDocument()->getName(AttributeId, m_attrId); } DOMString AttrImpl::nodeValue() const { return m_value; } DOMString AttrImpl::name() const { DOMString n = getDocument()->getName(AttributeId, m_attrId); // compat mode always return attribute names in lowercase. // that's not formally in the specification, but common // practice - a w3c erratum to DOM L2 is pending. if (m_htmlCompat) n = n.lower(); if (m_prefix && m_prefix->l) return DOMString(m_prefix) + ":" + n; return n; } void AttrImpl::setValue( const DOMString &v, int &exceptioncode ) { exceptioncode = 0; // ### according to the DOM docs, we should create an unparsed Text child // node here // do not interprete entities in the string, its literal! // NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly if (isReadOnly()) { exceptioncode = DOMException::NO_MODIFICATION_ALLOWED_ERR; return; } // ### what to do on 0 ? if (v.isNull()) { exceptioncode = DOMException::DOMSTRING_SIZE_ERR; return; } if (m_value == v.implementation()) return; if (m_element && m_attrId == ATTR_ID) m_element->updateId(m_value, v.implementation()); m_value->deref(); m_value = v.implementation(); m_value->ref(); if (m_element) { m_element->parseAttribute(m_attrId,m_value); m_element->attributeChanged(m_attrId); } } void AttrImpl::setNodeValue( const DOMString &v, int &exceptioncode ) { exceptioncode = 0; // NO_MODIFICATION_ALLOWED_ERR: taken care of by setValue() setValue(v, exceptioncode); } NodeImpl *AttrImpl::cloneNode ( bool /*deep*/) { AttrImpl* attr = new AttrImpl(0, docPtr(), m_attrId, m_value, m_prefix); attr->setHTMLCompat(m_htmlCompat); return attr; } // DOM Section 1.1.1 bool AttrImpl::childAllowed( NodeImpl *newChild ) { if(!newChild) return false; return childTypeAllowed(newChild->nodeType()); } bool AttrImpl::childTypeAllowed( unsigned short type ) { switch (type) { case Node::TEXT_NODE: case Node::ENTITY_REFERENCE_NODE: return true; break; default: return false; } } DOMString AttrImpl::toString() const { DOMString result; result += nodeName(); // FIXME: substitute entities for any instances of " or ' -- // maybe easier to just use text value and ignore existing // entity refs? if ( firstChild() ) { result += "=\""; for (NodeImpl *child = firstChild(); child != NULL; child = child->nextSibling()) { result += child->toString(); } result += "\""; } else if ( !nodeValue().isEmpty() ){ //remove the else once the AttributeImpl changes are merged result += "=\""; result += nodeValue(); result += "\""; } return result; } void AttrImpl::setElement(ElementImpl *element) { m_element = element; } // Strictly speaking, these two methods should not be needed, but // we can't fully deal with the mess that are DOM attributes right.. DOMStringImpl* AttrImpl::textContent() const { if (m_value) return new DOMStringImpl(m_value->s, m_value->l); else return 0; } void AttrImpl::setTextContent( const DOMString &text, int& exceptioncode ) { setValue(text, exceptioncode); } // ------------------------------------------------------------------------- void AttributeImpl::setValue(DOMStringImpl *value, ElementImpl *element) { assert(value); if (m_attrId) { if (m_data.value == value) return; if (element && m_attrId == ATTR_ID) element->updateId(m_data.value, value); m_data.value->deref(); m_data.value = value; m_data.value->ref(); if (element) { element->parseAttribute(this); element->attributeChanged(m_attrId); } } else { int exceptioncode = 0; m_data.attr->setValue(value,exceptioncode); // AttrImpl::setValue() calls parseAttribute() } } AttrImpl *AttributeImpl::createAttr(ElementImpl *element, DocumentImpl *docPtr) { if (m_attrId) { AttrImpl *attr = new AttrImpl(element,docPtr,m_attrId,m_data.value); if (!attr) return 0; attr->setHTMLCompat( docPtr->htmlMode() != DocumentImpl::XHtml ); m_data.value->deref(); m_data.attr = attr; m_data.attr->ref(); m_attrId = 0; /* "has implementation" flag */ } return m_data.attr; } void AttributeImpl::free() { if (m_attrId) { m_data.value->deref(); } else { m_data.attr->setElement(0); m_data.attr->deref(); } } // ------------------------------------------------------------------------- ElementImpl::ElementImpl(DocumentImpl *doc) : NodeBaseImpl(doc) { namedAttrMap = 0; m_styleDecls = 0; m_prefix = 0; } ElementImpl::~ElementImpl() { if(namedAttrMap) { namedAttrMap->detachFromElement(); namedAttrMap->deref(); } if (m_styleDecls) { m_styleDecls->setNode(0); m_styleDecls->setParent(0); m_styleDecls->deref(); } if (m_prefix) m_prefix->deref(); } unsigned short ElementImpl::nodeType() const { return Node::ELEMENT_NODE; } DOMStringImpl* ElementImpl::getAttributeImpl( NodeImpl::Id id, bool nsAware, DOMStringImpl* qName) const { if (!namedAttrMap) return 0; DOMStringImpl *value = namedAttrMap->getValue(id, nsAware, qName); if (value) return value; // then search in default attr in case it is not yet set NamedAttrMapImpl* dm = defaultMap(); value = dm ? dm->getValue(id, nsAware, qName) : 0; if (value) return value; return 0; } DOMString ElementImpl::getAttribute( NodeImpl::Id id, bool nsAware, const DOMString& qName) const { return DOMString(getAttributeImpl(id, nsAware, qName.implementation())); } void ElementImpl::setAttribute(NodeImpl::Id id, const DOMString &value, const DOMString& qName, int &exceptioncode) { // NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly if (isReadOnly()) { exceptioncode = DOMException::NO_MODIFICATION_ALLOWED_ERR; return; } attributes()->setValue(id, value.implementation(), (qName.isEmpty() ? 0: qName.implementation())); } void ElementImpl::setAttributeNS( const DOMString &namespaceURI, const DOMString &qualifiedName, const DOMString &value, int &exceptioncode ) { // NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly if (isReadOnly()) { exceptioncode = DOMException::NO_MODIFICATION_ALLOWED_ERR; return; } int colonPos; if (!DOM::checkQualifiedName(qualifiedName, namespaceURI, &colonPos, false/*nameCanBeNull*/, false/*nameCanBeEmpty*/, &exceptioncode)) return; DOMString prefix, localName; splitPrefixLocalName(qualifiedName.implementation(), prefix, localName, colonPos); NodeImpl::Id id = getDocument()->getId(AttributeId, namespaceURI.implementation(), prefix.implementation(), localName.implementation(), false, true /*lookupHTML*/); attributes()->setValue(id, value.implementation(), 0, prefix.implementation(), true /*nsAware*/, !namespaceURI.isNull() /*hasNS*/); } void ElementImpl::setAttribute(NodeImpl::Id id, const DOMString &value) { int exceptioncode = 0; setAttribute(id,value,DOMString(),exceptioncode); } void ElementImpl::setAttributeMap( NamedAttrMapImpl* list ) { // If setting the whole map changes the id attribute, we need to // call updateId. DOMStringImpl *oldId = namedAttrMap ? namedAttrMap->getValue(ATTR_ID) : 0; DOMStringImpl *newId = list ? list->getValue(ATTR_ID) : 0; if (oldId || newId) { updateId(oldId, newId); } if (namedAttrMap) { namedAttrMap->detachFromElement(); namedAttrMap->deref(); } namedAttrMap = list; if (namedAttrMap) { namedAttrMap->ref(); assert(namedAttrMap->m_element == 0); namedAttrMap->setElement(this); unsigned long len = namedAttrMap->length(); for (unsigned long i = 0; i < len; i++) { parseAttribute(&namedAttrMap->m_attrs[i]); attributeChanged(namedAttrMap->m_attrs[i].id()); } } } NodeImpl *ElementImpl::cloneNode(bool deep) { ElementImpl *clone; if ( !localName().isNull() ) clone = getDocument()->createElementNS( namespaceURI(), nodeName() ); else clone = getDocument()->createElement( nodeName() ); if (!clone) return 0; finishCloneNode( clone, deep ); return clone; } void ElementImpl::finishCloneNode( ElementImpl* clone, bool deep ) { // clone attributes if (namedAttrMap) clone->attributes()->copyAttributes(namedAttrMap); // clone individual style rules if (m_styleDecls) *(clone->styleRules()) = *m_styleDecls; if (deep) cloneChildNodes(clone); } DOMString ElementImpl::nodeName() const { return tagName(); } DOMString ElementImpl::namespaceURI() const { if (m_htmlCompat) return DOMString(); return getDocument()->getName(NamespaceId, id() >> 16); } DOMString ElementImpl::prefix() const { return m_prefix; } void ElementImpl::setPrefix( const DOMString &_prefix, int &exceptioncode ) { checkSetPrefix(_prefix, exceptioncode); if (exceptioncode) return; if (m_prefix == _prefix.implementation()) return; if (m_prefix) m_prefix->deref(); m_prefix = _prefix.implementation(); if (m_prefix) m_prefix->ref(); } void ElementImpl::createAttributeMap() const { namedAttrMap = new NamedAttrMapImpl(const_cast<ElementImpl*>(this)); namedAttrMap->ref(); } NamedAttrMapImpl* ElementImpl::defaultMap() const { return 0; } RenderStyle *ElementImpl::styleForRenderer(RenderObject * /*parentRenderer*/) { return getDocument()->styleSelector()->styleForElement(this); } RenderObject *ElementImpl::createRenderer(RenderArena *arena, RenderStyle *style) { if (getDocument()->documentElement() == this && style->display() == NONE) { // Ignore display: none on root elements. Force a display of block in that case. RenderBlock* result = new (arena) RenderBlock(this); if (result) result->setStyle(style); return result; } return RenderObject::createObject(this, style); } void ElementImpl::attach() { assert(!attached()); assert(!m_render); assert(parentNode()); #if SPEED_DEBUG < 1 createRendererIfNeeded(); #endif NodeBaseImpl::attach(); } void ElementImpl::close() { NodeImpl::close(); // Trigger all the addChild changes as one large dynamic appendChildren change if (attached()) backwardsStructureChanged(); } void ElementImpl::detach() { getDocument()->dynamicDomRestyler().resetDependencies(this); NodeBaseImpl::detach(); } void ElementImpl::structureChanged() { NodeBaseImpl::structureChanged(); if (!getDocument()->renderer()) return; // the document is about to be destroyed getDocument()->dynamicDomRestyler().restyleDepedent(this, StructuralDependency); // In theory BackwardsStructurualDependencies are indifferent to prepend, // but it's too rare to optimize. getDocument()->dynamicDomRestyler().restyleDepedent(this, BackwardsStructuralDependency); } void ElementImpl::backwardsStructureChanged() { NodeBaseImpl::backwardsStructureChanged(); if (!getDocument()->renderer()) return; // the document is about to be destroyed // Most selectors are not affected by append. Fire the few that are. getDocument()->dynamicDomRestyler().restyleDepedent(this, BackwardsStructuralDependency); } void ElementImpl::attributeChanged(NodeImpl::Id id) { if (!getDocument()->renderer()) return; // the document is about to be destroyed #if 0 // one-one dependencies for attributes disabled getDocument()->dynamicDomRestyler().restyleDepedent(this, AttributeDependency); #endif if (getDocument()->dynamicDomRestyler().checkDependency(id, PersonalDependency)) setChanged(true); if (getDocument()->dynamicDomRestyler().checkDependency(id, AncestorDependency)) setChangedAscendentAttribute(true); if (getDocument()->dynamicDomRestyler().checkDependency(id, PredecessorDependency) && parent()) // Any element that dependt on a predecessors attribute, also depend structurally on parent parent()->structureChanged(); } void ElementImpl::recalcStyle( StyleChange change ) { // ### should go away and be done in renderobject RenderStyle* _style = m_render ? m_render->style() : 0; bool hasParentRenderer = parent() ? parent()->attached() : false; #if 0 const char* debug; switch(change) { case NoChange: debug = "NoChange"; break; case NoInherit: debug= "NoInherit"; break; case Inherit: debug = "Inherit"; break; case Force: debug = "Force"; break; } tqDebug("recalcStyle(%d: %s, changed: %d)[%p: %s]", change, debug, changed(), this, tagName().string().latin1()); #endif if ( hasParentRenderer && (change >= Inherit || changed()) ) { RenderStyle *newStyle = getDocument()->styleSelector()->styleForElement(this); newStyle->ref(); StyleChange ch = diff( _style, newStyle ); if (ch == Detach) { if (attached()) detach(); // ### Suboptimal. Style gets calculated again. attach(); // attach recalulates the style for all children. No need to do it twice. setChanged( false ); setHasChangedChild( false ); newStyle->deref(); return; } else if (ch != NoChange) { if( m_render && newStyle ) { m_render->setStyle(newStyle); } } newStyle->deref(); if ( change != Force) change = ch; } // If a changed attribute has ancestor dependencies, restyle all children if (changedAscendentAttribute()) { change = Force; setChangedAscendentAttribute(false); } NodeImpl *n; for (n = _first; n; n = n->nextSibling()) { if ( change >= Inherit || n->isTextNode() || n->hasChangedChild() || n->changed() ) { //tqDebug(" (%p) calling recalcStyle on child %p/%s, change=%d", this, n, n->isElementNode() ? ((ElementImpl *)n)->tagName().string().latin1() : n->isTextNode() ? "text" : "unknown", change ); n->recalcStyle( change ); } } setChanged( false ); setHasChangedChild( false ); } bool ElementImpl::isFocusable() const { // Only make editable elements selectable if its parent element // is not editable. FIXME: this is not 100% right as non-editable elements // within editable elements are focusable too. return contentEditable() && !(parentNode() && parentNode()->contentEditable()); } // DOM Section 1.1.1 bool ElementImpl::childAllowed( NodeImpl *newChild ) { if (!childTypeAllowed(newChild->nodeType())) return false; // ### check xml element allowedness according to DTD // If either this node or the other node is an XML element node, allow regardless (we don't do DTD checks for XML // yet) if (isXMLElementNode() || newChild->isXMLElementNode()) return true; else return checkChild(id(), newChild->id(), !getDocument()->inCompatMode()); } bool ElementImpl::childTypeAllowed( unsigned short type ) { switch (type) { case Node::ELEMENT_NODE: case Node::TEXT_NODE: case Node::COMMENT_NODE: case Node::PROCESSING_INSTRUCTION_NODE: case Node::CDATA_SECTION_NODE: case Node::ENTITY_REFERENCE_NODE: return true; break; default: return false; } } void ElementImpl::scrollIntoView(bool /*alignToTop*/) { // ### kdWarning() << "non-standard scrollIntoView() not implemented" << endl; } void ElementImpl::createDecl( ) { m_styleDecls = new CSSStyleDeclarationImpl(0); m_styleDecls->ref(); m_styleDecls->setParent(getDocument()->elementSheet()); m_styleDecls->setNode(this); m_styleDecls->setStrictParsing( !getDocument()->inCompatMode() ); } void ElementImpl::dispatchAttrRemovalEvent(NodeImpl::Id /*id*/, DOMStringImpl * /*value*/) { // ### enable this stuff again if (!getDocument()->hasListenerType(DocumentImpl::DOMATTRMODIFIED_LISTENER)) return; //int exceptioncode = 0; //dispatchEvent(new MutationEventImpl(EventImpl::DOMATTRMODIFIED_EVENT,true,false,attr,attr->value(), //attr->value(), getDocument()->attrName(attr->id()),MutationEvent::REMOVAL),exceptioncode); } void ElementImpl::dispatchAttrAdditionEvent(NodeImpl::Id /*id*/, DOMStringImpl * /*value*/) { // ### enable this stuff again if (!getDocument()->hasListenerType(DocumentImpl::DOMATTRMODIFIED_LISTENER)) return; //int exceptioncode = 0; //dispatchEvent(new MutationEventImpl(EventImpl::DOMATTRMODIFIED_EVENT,true,false,attr,attr->value(), //attr->value(),getDocument()->attrName(attr->id()),MutationEvent::ADDITION),exceptioncode); } void ElementImpl::updateId(DOMStringImpl* oldId, DOMStringImpl* newId) { if (!inDocument()) return; if (oldId && oldId->l) removeId(DOMString(oldId).string()); if (newId && newId->l) addId(DOMString(newId).string()); } void ElementImpl::removeId(const TQString& id) { getDocument()->getElementByIdCache().remove(id, this); } void ElementImpl::addId(const TQString& id) { getDocument()->getElementByIdCache().add(id, this); } void ElementImpl::insertedIntoDocument() { // need to do superclass processing first so inDocument() is true // by the time we reach updateId NodeBaseImpl::insertedIntoDocument(); if (hasID()) { DOMString id = getAttribute(ATTR_ID); updateId(0, id.implementation()); } } void ElementImpl::removedFromDocument() { if (hasID()) { DOMString id = getAttribute(ATTR_ID); updateId(id.implementation(), 0); } NodeBaseImpl::removedFromDocument(); } DOMString ElementImpl::openTagStartToString(bool expandurls) const { DOMString result = DOMString("<") + tagName(); NamedAttrMapImpl *attrMap = attributes(true); if (attrMap) { unsigned long numAttrs = attrMap->length(); for (unsigned long i = 0; i < numAttrs; i++) { result += " "; AttributeImpl *attribute = attrMap->attrAt(i); AttrImpl *attr = attribute->attr(); if (attr) { result += attr->toString(); } else { result += getDocument()->getName( NodeImpl::AttributeId, attribute->id()); if (!attribute->value().isNull()) { result += "=\""; // FIXME: substitute entities for any instances of " or ' // Expand out all urls, i.e. the src and href attributes if(expandurls && ( attribute->id() == ATTR_SRC || attribute->id() == ATTR_HREF)) if(getDocument()) { //We need to sanitize the urls - strip out the passwords. //FIXME: are src= and href= the only places that might have a password and need to be sanitized? KURL safeURL(getDocument()->completeURL(attribute->value().string())); safeURL.setPass(TQString::null); result += safeURL.htmlURL(); } else { kdWarning() << "getDocument() returned false"; result += attribute->value(); } else result += attribute->value(); result += "\""; } } } } return result; } DOMString ElementImpl::selectionToString(NodeImpl *selectionStart, NodeImpl *selectionEnd, int startOffset, int endOffset, bool &found) const { DOMString result = openTagStartToString(); if (hasChildNodes()) { result += ">"; for (NodeImpl *child = firstChild(); child != NULL; child = child->nextSibling()) { result += child->selectionToString(selectionStart, selectionEnd, startOffset, endOffset, found); // this might set found to true if(child == selectionEnd) found = true; if(found) break; } result += "</"; result += tagName(); result += ">"; } else { result += " />"; } return result; } DOMString ElementImpl::toString() const { TQString result = openTagStartToString().string(); //Accumulate in TQString, since DOMString can't append well. if (hasChildNodes()) { result += ">"; for (NodeImpl *child = firstChild(); child != NULL; child = child->nextSibling()) { DOMString kid = child->toString(); result += TQConstString(kid.unicode(), kid.length()).string(); } result += "</"; result += tagName().string(); result += ">"; } else if (result.length() == 1) { // ensure we dont get results like < /> can happen when serialize document result = ""; } else { result += " />"; } return result; } bool ElementImpl::contentEditable() const { #if 0 DOM::CSSPrimitiveValueImpl *val = static_cast<DOM::CSSPrimitiveValueImpl *> (const_cast<ElementImpl *>(this)->styleRules() ->getPropertyCSSValue(CSS_PROP__KONQ_USER_INPUT)); // kdDebug() << "val" << val << endl; return val ? val->getIdent() == CSS_VAL_ENABLED : false; #endif return NodeImpl::contentEditable(); } void ElementImpl::setContentEditable(bool enabled) { // FIXME: the approach is flawed, better use an enum instead of bool int value; if (enabled) value = CSS_VAL_ENABLED; else { // Intelligently use "none" or "disabled", depending on the type of // element // FIXME: intelligence not impl'd yet value = CSS_VAL_NONE; // FIXME: reset caret if it is in this node or a child }/*end if*/ // FIXME: use addCSSProperty when I get permission to move it here // kdDebug(6000) << "CSS_PROP__TDEHTML_USER_INPUT: "<< value << endl; styleRules()->setProperty(CSS_PROP__TDEHTML_USER_INPUT, value, false, true); setChanged(); } // ------------------------------------------------------------------------- XMLElementImpl::XMLElementImpl(DocumentImpl *doc, NodeImpl::Id id) : ElementImpl(doc) { // Called from createElement(). In this case localName, prefix, and namespaceURI all need to be null. m_id = id; } XMLElementImpl::XMLElementImpl(DocumentImpl *doc, NodeImpl::Id id, DOMStringImpl *_prefix) : ElementImpl(doc) { // Called from createElementNS() m_id = id; m_prefix = _prefix; if (m_prefix) m_prefix->ref(); } XMLElementImpl::~XMLElementImpl() { } DOMString XMLElementImpl::localName() const { if ( m_htmlCompat ) return DOMString(); // was created with non-namespace-aware createElement() return getDocument()->getName(ElementId, m_id); } DOMString XMLElementImpl::tagName() const { DOMString tn = getDocument()->getName(ElementId, id()); if (m_htmlCompat) tn = tn.upper(); if (m_prefix) return DOMString(m_prefix) + ":" + tn; return tn; } NodeImpl *XMLElementImpl::cloneNode ( bool deep ) { XMLElementImpl *clone = new XMLElementImpl(docPtr(), id(), m_prefix); finishCloneNode( clone, deep ); return clone; } // ------------------------------------------------------------------------- NamedAttrMapImpl::NamedAttrMapImpl(ElementImpl *element) : m_element(element), m_attrs(0), m_attrCount(0) { } NamedAttrMapImpl::~NamedAttrMapImpl() { for (unsigned long i = 0; i < m_attrCount; i++) m_attrs[i].free(); free(m_attrs); } NodeImpl *NamedAttrMapImpl::getNamedItem ( NodeImpl::Id id, bool nsAware, DOMStringImpl* qName ) const { if (!m_element) return 0; unsigned int mask = nsAware ? ~0L : NodeImpl_IdLocalMask; id = (id & mask); for (unsigned long i = 0; i < m_attrCount; i++) { if ((m_attrs[i].id() & mask) == id) { // if we are called with a qualified name, filter out NS-aware elements with non-matching name. if (qName && (namespacePart(m_attrs[i].id()) != defaultNamespace) && strcasecmp(m_attrs[i].name(), DOMString(qName))) continue; return m_attrs[i].createAttr(m_element,m_element->docPtr()); } } return 0; } Node NamedAttrMapImpl::removeNamedItem ( NodeImpl::Id id, bool nsAware, DOMStringImpl* qName, int &exceptioncode ) { if (!m_element) { exceptioncode = DOMException::NOT_FOUND_ERR; return 0; } // NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly if (isReadOnly()) { exceptioncode = DOMException::NO_MODIFICATION_ALLOWED_ERR; return 0; } unsigned int mask = nsAware ? ~0L : NodeImpl_IdLocalMask; id = (id & mask); for (unsigned long i = 0; i < m_attrCount; i++) { if ((m_attrs[i].id() & mask) == id) { // if we are called with a qualified name, filter out NS-aware elements with non-matching name. if (qName && (namespacePart(m_attrs[i].id()) != defaultNamespace) && strcasecmp(m_attrs[i].name(), DOMString(qName))) continue; id = m_attrs[i].id(); if (id == ATTR_ID) m_element->updateId(m_attrs[i].val(), 0); Node removed(m_attrs[i].createAttr(m_element,m_element->docPtr())); m_attrs[i].free(); memmove(m_attrs+i,m_attrs+i+1,(m_attrCount-i-1)*sizeof(AttributeImpl)); m_attrCount--; m_attrs = (AttributeImpl*)realloc(m_attrs,m_attrCount*sizeof(AttributeImpl)); m_element->parseAttribute(id,0); m_element->attributeChanged(id); return removed; } } // NOT_FOUND_ERR: Raised if there is no node with the specified namespaceURI // and localName in this map. exceptioncode = DOMException::NOT_FOUND_ERR; return 0; } Node NamedAttrMapImpl::setNamedItem ( NodeImpl* arg, bool nsAware, DOMStringImpl* qName, int &exceptioncode ) { if (!m_element) { exceptioncode = DOMException::NOT_FOUND_ERR; return 0; } // NO_MODIFICATION_ALLOWED_ERR: Raised if this map is readonly. if (isReadOnly()) { exceptioncode = DOMException::NO_MODIFICATION_ALLOWED_ERR; return 0; } // WRONG_DOCUMENT_ERR: Raised if arg was created from a different document than the one that created this map. if (arg->getDocument() != m_element->getDocument()) { exceptioncode = DOMException::WRONG_DOCUMENT_ERR; return 0; } // HIERARCHY_REQUEST_ERR: Raised if an attempt is made to add a node doesn't belong in this NamedNodeMap if (!arg->isAttributeNode()) { exceptioncode = DOMException::HIERARCHY_REQUEST_ERR; return 0; } AttrImpl *attr = static_cast<AttrImpl*>(arg); // INUSE_ATTRIBUTE_ERR: Raised if arg is an Attr that is already an attribute of another Element object. // The DOM user must explicitly clone Attr nodes to re-use them in other elements. if (attr->ownerElement() && attr->ownerElement() != m_element) { exceptioncode = DOMException::INUSE_ATTRIBUTE_ERR; return 0; } if (attr->ownerElement() == m_element) { // Already have this attribute. // DOMTS core-1 test "hc_elementreplaceattributewithself" says we should return it. return attr; } unsigned int mask = nsAware ? ~0L : NodeImpl_IdLocalMask; NodeImpl::Id id = (attr->id() & mask); for (unsigned long i = 0; i < m_attrCount; i++) { if ((m_attrs[i].id() & mask) == id) { // if we are called with a qualified name, filter out NS-aware elements with non-matching name. if (qName && (namespacePart(m_attrs[i].id()) != defaultNamespace) && strcasecmp(m_attrs[i].name(), DOMString(qName))) continue; // Attribute exists; replace it if (id == ATTR_ID) m_element->updateId(m_attrs[i].val(), attr->val()); Node replaced = m_attrs[i].createAttr(m_element,m_element->docPtr()); m_attrs[i].free(); m_attrs[i].m_attrId = 0; /* "has implementation" flag */ m_attrs[i].m_data.attr = attr; m_attrs[i].m_data.attr->ref(); attr->setElement(m_element); m_element->parseAttribute(&m_attrs[i]); m_element->attributeChanged(m_attrs[i].id()); // ### dispatch mutation events return replaced; } } // No existing attribute; add to list m_attrCount++; m_attrs = (AttributeImpl*)realloc(m_attrs,m_attrCount*sizeof(AttributeImpl)); m_attrs[m_attrCount-1].m_attrId = 0; /* "has implementation" flag */ m_attrs[m_attrCount-1].m_data.attr = attr; m_attrs[m_attrCount-1].m_data.attr->ref(); attr->setElement(m_element); if (id == ATTR_ID) m_element->updateId(0, attr->val()); m_element->parseAttribute(&m_attrs[m_attrCount-1]); m_element->attributeChanged(m_attrs[m_attrCount-1].id()); // ### dispatch mutation events return 0; } NodeImpl *NamedAttrMapImpl::item ( unsigned long index ) const { if (!m_element) return 0; if (index >= m_attrCount) return 0; else return m_attrs[index].createAttr(m_element,m_element->docPtr()); } unsigned long NamedAttrMapImpl::length( ) const { if (!m_element) return 0; return m_attrCount; } NodeImpl::Id NamedAttrMapImpl::idAt(unsigned long index) const { assert(index <= m_attrCount); return m_attrs[index].id(); } DOMStringImpl *NamedAttrMapImpl::valueAt(unsigned long index) const { assert(index <= m_attrCount); return m_attrs[index].val(); } DOMStringImpl *NamedAttrMapImpl::getValue(NodeImpl::Id id, bool nsAware, DOMStringImpl* qName) const { unsigned int mask = nsAware ? ~0L : NodeImpl_IdLocalMask; id = (id & mask); for (unsigned long i = 0; i < m_attrCount; i++) if ((m_attrs[i].id() & mask) == id) { // if we are called with a qualified name, filter out NS-aware elements with non-matching name. if (qName && (namespacePart(m_attrs[i].id()) != defaultNamespace) && strcasecmp(m_attrs[i].name(), qName)) continue; return m_attrs[i].val(); } return 0; } void NamedAttrMapImpl::setValue(NodeImpl::Id id, DOMStringImpl *value, DOMStringImpl* qName, DOMStringImpl *prefix, bool nsAware, bool hasNS) { assert( !(qName && nsAware) ); if (!id) return; // Passing in a null value here causes the attribute to be removed. This is a tdehtml extension // (the spec does not specify what to do in this situation). int exceptioncode = 0; if (!value) { removeNamedItem(id, nsAware, qName, exceptioncode); return; } unsigned int mask = nsAware ? ~0L : NodeImpl_IdLocalMask; NodeImpl::Id mid = (id & mask); // Check for an existing attribute. for (unsigned long i = 0; i < m_attrCount; i++) { if ((m_attrs[i].id() & mask) == mid) { // if we are called with a qualified name, filter out NS-aware elements with non-matching name. if (qName && (namespacePart(m_attrs[i].id()) != defaultNamespace) && strcasecmp(m_attrs[i].name(), DOMString(qName))) continue; if (prefix) m_attrs[i].attr()->setPrefix(prefix,exceptioncode); m_attrs[i].setValue(value,m_element); // ### dispatch mutation events return; } } // No existing matching attribute; add a new one m_attrCount++; m_attrs = (AttributeImpl*)realloc(m_attrs,m_attrCount*sizeof(AttributeImpl)); if (!nsAware) { // Called from setAttribute()... we only have a name m_attrs[m_attrCount-1].m_attrId = id; m_attrs[m_attrCount-1].m_data.value = value; m_attrs[m_attrCount-1].m_data.value->ref(); } else { // Called from setAttributeNS()... need to create a full AttrImpl here if(!m_element) return; m_attrs[m_attrCount-1].m_data.attr = new AttrImpl(m_element,m_element->docPtr(), id, value, prefix); m_attrs[m_attrCount-1].m_attrId = 0; /* "has implementation" flag */ m_attrs[m_attrCount-1].m_data.attr->ref(); m_attrs[m_attrCount-1].m_data.attr->setHTMLCompat( !hasNS && m_element->getDocument()->htmlMode() != DocumentImpl::XHtml ); } if (m_element) { if (id == ATTR_ID) m_element->updateId(0, value); m_element->parseAttribute(&m_attrs[m_attrCount-1]); m_element->attributeChanged(m_attrs[m_attrCount-1].id()); } // ### dispatch mutation events } Attr NamedAttrMapImpl::removeAttr(AttrImpl *attr) { for (unsigned long i = 0; i < m_attrCount; i++) { if (m_attrs[i].attr() == attr) { NodeImpl::Id id = m_attrs[i].id(); if (id == ATTR_ID) m_element->updateId(attr->val(), 0); Node removed(m_attrs[i].createAttr(m_element,m_element->docPtr())); m_attrs[i].free(); memmove(m_attrs+i,m_attrs+i+1,(m_attrCount-i-1)*sizeof(AttributeImpl)); m_attrCount--; m_attrs = (AttributeImpl*)realloc(m_attrs,m_attrCount*sizeof(AttributeImpl)); m_element->parseAttribute(id,0); m_element->attributeChanged(id); // ### dispatch mutation events return removed; } } return 0; } NodeImpl::Id NamedAttrMapImpl::mapId(DOMStringImpl* namespaceURI, DOMStringImpl* localName, bool readonly) { if (!m_element) return 0; return m_element->getDocument()->getId(NodeImpl::AttributeId, namespaceURI, 0, localName, readonly, true /*lookupHTML*/); } void NamedAttrMapImpl::copyAttributes(NamedAttrMapImpl *other) { assert(m_element); unsigned long i; for (i = 0; i < m_attrCount; i++) { if (m_attrs[i].id() == ATTR_ID) m_element->updateId(m_attrs[i].val(), 0); m_attrs[i].free(); } m_attrCount = other->m_attrCount; m_attrs = (AttributeImpl*)realloc(m_attrs,m_attrCount*sizeof(AttributeImpl)); for (i = 0; i < m_attrCount; i++) { m_attrs[i].m_attrId = other->m_attrs[i].m_attrId; if (m_attrs[i].m_attrId) { m_attrs[i].m_data.value = other->m_attrs[i].m_data.value; m_attrs[i].m_data.value->ref(); } else { m_attrs[i].m_data.attr = static_cast<AttrImpl*>(other->m_attrs[i].m_data.attr->cloneNode(true)); m_attrs[i].m_data.attr->ref(); m_attrs[i].m_data.attr->setElement(m_element); } if (m_attrs[i].id() == ATTR_ID) m_element->updateId(0, m_attrs[i].val()); m_element->parseAttribute(&m_attrs[i]); m_element->attributeChanged(m_attrs[i].id()); } } void NamedAttrMapImpl::setElement(ElementImpl *element) { assert(!m_element); m_element = element; for (unsigned long i = 0; i < m_attrCount; i++) if (m_attrs[i].attr()) m_attrs[i].attr()->setElement(element); } void NamedAttrMapImpl::detachFromElement() { // This makes the map invalid; nothing can really be done with it now since it's not // associated with an element. But we have to keep it around in memory in case there // are still references to it. m_element = 0; for (unsigned long i = 0; i < m_attrCount; i++) m_attrs[i].free(); free(m_attrs); m_attrs = 0; m_attrCount = 0; }