summaryrefslogtreecommitdiffstats
path: root/tdehtml/xml/dom_elementimpl.h
diff options
context:
space:
mode:
Diffstat (limited to 'tdehtml/xml/dom_elementimpl.h')
-rw-r--r--tdehtml/xml/dom_elementimpl.h392
1 files changed, 392 insertions, 0 deletions
diff --git a/tdehtml/xml/dom_elementimpl.h b/tdehtml/xml/dom_elementimpl.h
new file mode 100644
index 000000000..e528d7e24
--- /dev/null
+++ b/tdehtml/xml/dom_elementimpl.h
@@ -0,0 +1,392 @@
+/*
+ * 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) 2003 Apple Computer, Inc.
+ *
+ * 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.
+ *
+ */
+#ifndef _DOM_ELEMENTImpl_h_
+#define _DOM_ELEMENTImpl_h_
+
+#include "dom_nodeimpl.h"
+#include "dom/dom_exception.h"
+#include "dom/dom_element.h"
+#include "xml/dom_stringimpl.h"
+#include "misc/shared.h"
+
+namespace tdehtml {
+ class CSSStyleSelector;
+}
+
+namespace DOM {
+
+class ElementImpl;
+class DocumentImpl;
+class NamedAttrMapImpl;
+
+// Attr can have Text and EntityReference children
+// therefore it has to be a fullblown Node. The plan
+// is to dynamically allocate a textchild and store the
+// resulting nodevalue in the AttributeImpl upon
+// destruction. however, this is not yet implemented.
+class AttrImpl : public NodeBaseImpl
+{
+ friend class ElementImpl;
+ friend class NamedAttrMapImpl;
+
+public:
+ AttrImpl(ElementImpl* element, DocumentImpl* docPtr, NodeImpl::Id attrId,
+ DOMStringImpl *value, DOMStringImpl *prefix = 0);
+ ~AttrImpl();
+
+private:
+ AttrImpl(const AttrImpl &other);
+ AttrImpl &operator = (const AttrImpl &other);
+public:
+
+ // DOM methods & attributes for Attr
+ bool specified() const { return m_specified; }
+ ElementImpl* ownerElement() const { return m_element; }
+ void setOwnerElement( ElementImpl* impl ) { m_element = impl; }
+ DOMString name() const;
+
+ //DOMString value() const;
+ void setValue( const DOMString &v, int &exceptioncode );
+
+ // DOM methods overridden from parent classes
+ virtual DOMString nodeName() const;
+ virtual unsigned short nodeType() const;
+ virtual DOMString prefix() const;
+ virtual void setPrefix(const DOMString &_prefix, int &exceptioncode );
+ virtual DOMString namespaceURI() const;
+ virtual DOMString localName() const;
+
+ virtual DOMString nodeValue() const;
+ virtual void setNodeValue( const DOMString &, int &exceptioncode );
+ virtual NodeImpl *cloneNode ( bool deep );
+
+ virtual DOMStringImpl* textContent() const;
+ virtual void setTextContent( const DOMString &text, int& exceptioncode );
+
+
+ // Other methods (not part of DOM)
+ virtual bool isAttributeNode() const { return true; }
+ virtual bool childAllowed( NodeImpl *newChild );
+ virtual bool childTypeAllowed( unsigned short type );
+ virtual NodeImpl::Id id() const { return m_attrId; }
+
+ virtual DOMString toString() const;
+
+ void setElement(ElementImpl *element);
+ DOMStringImpl *val() { return m_value; }
+
+protected:
+ ElementImpl *m_element;
+ NodeImpl::Id m_attrId;
+ DOMStringImpl *m_value;
+ DOMStringImpl *m_prefix;
+ DOMStringImpl *m_localName;
+};
+
+// Mini version of AttrImpl internal to NamedAttrMapImpl.
+// Stores either the id and value of an attribute
+// (in the case of m_attrId != 0), or a pointer to an AttrImpl (if m_attrId == 0)
+// The latter case only happens when the Attr node is requested by some DOM
+// code or is an XML attribute.
+// In most cases the id and value is all we need to store, which is more
+// memory efficient.
+struct AttributeImpl
+{
+ NodeImpl::Id id() const { return m_attrId ? m_attrId : m_data.attr->id(); }
+ DOMStringImpl *val() const { return m_attrId ? m_data.value : m_data.attr->val(); }
+ DOMString value() const { return val(); }
+ AttrImpl *attr() const { return m_attrId ? 0 : m_data.attr; }
+ DOMString namespaceURI() { return m_attrId ? DOMString() : m_data.attr->namespaceURI(); }
+ DOMString prefix() { return m_attrId ? DOMString() : m_data.attr->prefix(); }
+ DOMString localName() { return m_attrId ? DOMString() : m_data.attr->localName(); }
+ DOMString name() { return m_attrId ? DOMString() : m_data.attr->name(); }
+
+ void setValue(DOMStringImpl *value, ElementImpl *element);
+ AttrImpl *createAttr(ElementImpl *element, DocumentImpl *docPtr);
+ void free();
+
+ NodeImpl::Id m_attrId;
+ union {
+ DOMStringImpl *value;
+ AttrImpl *attr;
+ } m_data;
+};
+
+class ElementImpl : public NodeBaseImpl
+{
+ friend class DocumentImpl;
+ friend class NamedAttrMapImpl;
+ friend class AttrImpl;
+ friend class NodeImpl;
+ friend class tdehtml::CSSStyleSelector;
+public:
+ ElementImpl(DocumentImpl *doc);
+ ~ElementImpl();
+
+ DOMString getAttribute( NodeImpl::Id id, bool nsAware = 0, const DOMString& qName = DOMString() ) const;
+ DOMStringImpl* getAttributeImpl( NodeImpl::Id id, bool nsAware = 0, DOMStringImpl* qName = 0 ) const;
+ void setAttribute( NodeImpl::Id id, const DOMString &value, const DOMString &qName,
+ int &exceptioncode );
+ void setAttributeNS( const DOMString &namespaceURI, const DOMString &qualifiedName,
+ const DOMString& value, int &exceptioncode );
+ virtual DOMString prefix() const;
+ void setPrefix(const DOMString &_prefix, int &exceptioncode );
+ virtual DOMString namespaceURI() const;
+
+ // DOM methods overridden from parent classes
+ virtual DOMString tagName() const = 0;
+ virtual unsigned short nodeType() const;
+ virtual NodeImpl *cloneNode ( bool deep );
+ virtual DOMString nodeName() const;
+ virtual NodeImpl::Id id() const = 0;
+ virtual bool isElementNode() const { return true; }
+ virtual void insertedIntoDocument();
+ virtual void removedFromDocument();
+
+ // convenience methods which ignore exceptions
+ void setAttribute (NodeImpl::Id id, const DOMString &value);
+
+ NamedAttrMapImpl* attributes(bool readonly = false) const
+ {
+ if (!readonly && !namedAttrMap) createAttributeMap();
+ return namedAttrMap;
+ }
+
+ //This is always called, whenever an attribute changed
+ virtual void parseAttribute(AttributeImpl *) {}
+ void parseAttribute(NodeImpl::Id attrId, DOMStringImpl *value) {
+ AttributeImpl aimpl;
+ aimpl.m_attrId = attrId;
+ aimpl.m_data.value = value;
+ parseAttribute(&aimpl);
+ }
+
+ // not part of the DOM
+ void setAttributeMap ( NamedAttrMapImpl* list );
+
+ // State of the element.
+ virtual TQString state() { return TQString::null; }
+
+ virtual void attach();
+ virtual void close();
+ virtual void detach();
+ virtual void structureChanged();
+ virtual void backwardsStructureChanged();
+ virtual void attributeChanged(NodeImpl::Id attrId);
+
+ virtual tdehtml::RenderStyle *styleForRenderer(tdehtml::RenderObject *parent);
+ virtual tdehtml::RenderObject *createRenderer(tdehtml::RenderArena *, tdehtml::RenderStyle *);
+ virtual void recalcStyle( StyleChange = NoChange );
+
+ virtual void mouseEventHandler( MouseEvent* /*ev*/, bool /*inside*/ ) {}
+ virtual bool isFocusable() const;
+ virtual bool childAllowed( NodeImpl *newChild );
+ virtual bool childTypeAllowed( unsigned short type );
+
+ DOM::CSSStyleDeclarationImpl *styleRules() {
+ if (!m_styleDecls) createDecl();
+ return m_styleDecls;
+ }
+
+ void dispatchAttrRemovalEvent(NodeImpl::Id id, DOMStringImpl *value);
+ void dispatchAttrAdditionEvent(NodeImpl::Id id, DOMStringImpl *value);
+
+ virtual DOMString toString() const;
+ virtual DOMString selectionToString(NodeImpl *selectionStart, NodeImpl *selectionEnd, int startOffset, int endOffset, bool &found) const;
+
+ virtual bool contentEditable() const;
+ void setContentEditable(bool enabled);
+
+ void scrollIntoView(bool alignToTop);
+
+ /** Returns the opening tag and properties.
+ * Examples: '<b', '<img alt="hello" src="image.png"
+ *
+ * For security reasons, passwords are stripped out of all src= and
+ * href= tags if expandurls is turned on.
+ *
+ * @param expandurls If this is set then in the above example, it would give
+ * src="http://website.com/image.png". Note that the password
+ * is stripped out of the url.
+ *
+ * DOM::RangeImpl uses this which is why it is public.
+ */
+ DOMString openTagStartToString(bool expandurls = false) const;
+
+ void updateId(DOMStringImpl* oldId, DOMStringImpl* newId);
+ //Called when mapping from id to this node in document should be removed
+ virtual void removeId(const TQString& id);
+ //Called when mapping from id to this node in document should be added
+ virtual void addId (const TQString& id);
+
+protected:
+ void createAttributeMap() const;
+ void createDecl();
+ void finishCloneNode( ElementImpl *clone, bool deep );
+
+private:
+ // map of default attributes. derived element classes are responsible
+ // for setting this according to the corresponding element description
+ // in the DTD
+ virtual NamedAttrMapImpl* defaultMap() const;
+
+protected: // member variables
+ mutable NamedAttrMapImpl *namedAttrMap;
+
+ DOM::CSSStyleDeclarationImpl *m_styleDecls;
+ DOMStringImpl *m_prefix;
+};
+
+
+class XMLElementImpl : public ElementImpl
+{
+
+public:
+ XMLElementImpl(DocumentImpl *doc, NodeImpl::Id id);
+ XMLElementImpl(DocumentImpl *doc, NodeImpl::Id id, DOMStringImpl *_qualifiedName);
+ ~XMLElementImpl();
+
+ // DOM methods overridden from parent classes
+ virtual DOMString tagName() const;
+ virtual DOMString localName() const;
+ virtual NodeImpl *cloneNode ( bool deep );
+
+ // Other methods (not part of DOM)
+ virtual bool isXMLElementNode() const { return true; }
+ virtual Id id() const { return m_id; }
+
+protected:
+ Id m_id;
+};
+
+// the map of attributes of an element
+class NamedAttrMapImpl : public NamedNodeMapImpl
+{
+ friend class ElementImpl;
+public:
+ NamedAttrMapImpl(ElementImpl *element);
+ virtual ~NamedAttrMapImpl();
+
+ // DOM methods & attributes for NamedNodeMap
+ virtual NodeImpl *getNamedItem ( NodeImpl::Id id, bool nsAware = false, DOMStringImpl* qName = 0 ) const;
+ virtual Node removeNamedItem ( NodeImpl::Id id, bool nsAware, DOMStringImpl* qName, int &exceptioncode );
+ virtual Node setNamedItem ( NodeImpl* arg, bool nsAware, DOMStringImpl* qName, int &exceptioncode );
+
+ virtual NodeImpl *item ( unsigned long index ) const;
+ virtual unsigned long length( ) const;
+
+ // Other methods (not part of DOM)
+ virtual bool isReadOnly() { return false; }
+
+ AttributeImpl *attrAt(unsigned long index) const { return &m_attrs[index]; }
+ // ### replace idAt and getValueAt with attrAt
+ NodeImpl::Id idAt(unsigned long index) const;
+ DOMStringImpl *valueAt(unsigned long index) const;
+ DOMStringImpl *getValue(NodeImpl::Id id, bool nsAware = false, DOMStringImpl* qName = 0) const;
+ void setValue(NodeImpl::Id id, DOMStringImpl *value, DOMStringImpl* qName = 0,
+ DOMStringImpl *prefix = 0, bool nsAware = false, bool hasNS = false);
+ Attr removeAttr(AttrImpl *attr);
+ NodeImpl::Id mapId(DOMStringImpl* namespaceURI, DOMStringImpl* localName, bool readonly);
+ void copyAttributes(NamedAttrMapImpl *other);
+ void setElement(ElementImpl *element);
+ void detachFromElement();
+
+protected:
+ ElementImpl *m_element;
+ AttributeImpl *m_attrs;
+ unsigned long m_attrCount;
+};
+
+// ------------ inline DOM helper functions ---------------
+
+inline bool checkQualifiedName(const DOMString &qualifiedName, const DOMString &namespaceURI, int *colonPos,
+ bool nameCanBeNull, bool nameCanBeEmpty, int *pExceptioncode)
+{
+
+ // Not mentioned in spec: throw NAMESPACE_ERR if no qualifiedName supplied
+ if (!nameCanBeNull && qualifiedName.isNull()) {
+ if (pExceptioncode)
+ *pExceptioncode = DOMException::NAMESPACE_ERR;
+ return false;
+ }
+
+ // INVALID_CHARACTER_ERR: Raised if the specified qualified name contains an illegal character.
+ if (!qualifiedName.isNull() && !Element::tdehtmlValidQualifiedName(qualifiedName)
+ && ( !qualifiedName.isEmpty() || !nameCanBeEmpty ) ) {
+ if (pExceptioncode)
+ *pExceptioncode = DOMException::INVALID_CHARACTER_ERR;
+ return false;
+ }
+
+ // NAMESPACE_ERR:
+ // - Raised if the qualifiedName is malformed,
+ // - if the qualifiedName has a prefix and the namespaceURI is null, or
+ // - if the qualifiedName is null and the namespaceURI is different from null
+ // - if the qualifiedName has a prefix that is "xml" and the namespaceURI is different
+ // from "http://www.w3.org/XML/1998/namespace" [Namespaces].
+ int colonpos = -1;
+ uint i;
+ DOMStringImpl *qname = qualifiedName.implementation();
+ for (i = 0 ; i < qname->l ; i++) {
+ if ((*qname)[i] == ':') {
+ colonpos = i;
+ break;
+ }
+ }
+
+ if (!qualifiedName.isNull() && Element::tdehtmlMalformedQualifiedName(qualifiedName) ||
+ (colonpos >= 0 && namespaceURI.isNull()) ||
+ (qualifiedName.isNull() && !namespaceURI.isNull()) ||
+ (colonpos == 3 && qualifiedName[0] == 'x' && qualifiedName[1] == 'm' && qualifiedName[2] == 'l' &&
+ namespaceURI != "http://www.w3.org/XML/1998/namespace")) {
+ if (pExceptioncode)
+ *pExceptioncode = DOMException::NAMESPACE_ERR;
+ return false;
+ }
+ if(colonPos)
+ *colonPos = colonpos;
+ return true;
+}
+
+inline void splitPrefixLocalName(DOMStringImpl *qualifiedName, DOMString &prefix, DOMString &localName, int colonPos = -2)
+{
+ if (colonPos == -2)
+ for (uint i = 0 ; i < qualifiedName->l ; ++i)
+ if (qualifiedName->s[i] == ':') {
+ colonPos = i;
+ break;
+ }
+ if (colonPos >= 0) {
+ prefix = qualifiedName->copy();
+ localName = prefix.split(colonPos+1);
+ prefix.implementation()->truncate(colonPos);
+ } else
+ localName = qualifiedName->copy();
+}
+
+} //namespace
+
+#endif
generated by cgit v1.2.1 (git 2.18.0) at 2024-11-09 06:00:19 +0000