Rename a number of libraries and executables to avoid conflicts with KDE4

1 files changed, 310 insertions, 0 deletions

diff --git a/tdehtml/dom/dom_xml.h b/tdehtml/dom/dom_xml.h
new file mode 100644
index 000000000..12e70d9e5
--- /dev/null
+++ b/tdehtml/dom/dom_xml.h
@@ -0,0 +1,310 @@
+/*
+ * This file is part of the DOM implementation for KDE.
+ *
+ * (C) 1999 Lars Knoll (knoll@kde.org)
+ *
+ * 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.
+ *
+ * This file includes excerpts from the Document Object Model (DOM)
+ * Level 1 Specification (Recommendation)
+ * http://www.w3.org/TR/REC-DOM-Level-1/
+ * Copyright © World Wide Web Consortium , (Massachusetts Institute of
+ * Technology , Institut National de Recherche en Informatique et en
+ * Automatique , Keio University ). All Rights Reserved.
+ *
+ */
+#ifndef _DOM_XML_h
+#define _DOM_XML_h
+
+#include <dom/dom_text.h>
+#include <dom/css_stylesheet.h>
+
+namespace DOM {
+
+class CDATASectionImpl;
+class EntityImpl;
+class EntityReferenceImpl;
+class NotationImpl;
+class ProcessingInstructionImpl;
+
+
+
+/**
+ * CDATA sections are used to escape blocks of text containing
+ * characters that would otherwise be regarded as markup. The only
+ * delimiter that is recognized in a CDATA section is the "]]&gt;"
+ * string that ends the CDATA section. CDATA sections can not be
+ * nested. The primary purpose is for including material such as XML
+ * fragments, without needing to escape all the delimiters.
+ *
+ *  The \c DOMString attribute of the \c Text
+ * node holds the text that is contained by the CDATA section. Note
+ * that this may contain characters that need to be escaped outside of
+ * CDATA sections and that, depending on the character encoding
+ * ("charset") chosen for serialization, it may be impossible to write
+ * out some characters as part of a CDATA section.
+ *
+ *  The \c CDATASection interface inherits the
+ * \c CharacterData interface through the \c Text
+ * interface. Adjacent \c CDATASections nodes are not
+ * merged by use of the Element.normalize() method.
+ *
+ */
+class KHTML_EXPORT CDATASection : public Text
+{
+    friend class Document;
+public:
+    CDATASection();
+    CDATASection(const CDATASection &other);
+    CDATASection(const Node &other) : Text()
+         {(*this)=other;}
+
+    CDATASection & operator = (const Node &other);
+    CDATASection & operator = (const CDATASection &other);
+
+    ~CDATASection();
+protected:
+    CDATASection(CDATASectionImpl *i);
+};
+
+class DOMString;
+
+/**
+ * This interface represents an entity, either parsed or unparsed, in
+ * an XML document. Note that this models the entity itself not the
+ * entity declaration. \c Entity declaration modeling has
+ * been left for a later Level of the DOM specification.
+ *
+ *  The \c nodeName attribute that is inherited from
+ * \c Node contains the name of the entity.
+ *
+ *  An XML processor may choose to completely expand entities before
+ * the structure model is passed to the DOM; in this case there will
+ * be no \c EntityReference nodes in the document tree.
+ *
+ *  XML does not mandate that a non-validating XML processor read and
+ * process entity declarations made in the external subset or declared
+ * in external parameter entities. This means that parsed entities
+ * declared in the external subset need not be expanded by some
+ * classes of applications, and that the replacement value of the
+ * entity may not be available. When the replacement value is
+ * available, the corresponding \c Entity node's child
+ * list represents the structure of that replacement text. Otherwise,
+ * the child list is empty.
+ *
+ *  The resolution of the children of the \c Entity (the
+ * replacement value) may be lazily evaluated; actions by the user
+ * (such as calling the \c childNodes method on the
+ * \c Entity Node) are assumed to trigger the evaluation.
+ *
+ *  The DOM Level 1 does not support editing \c Entity
+ * nodes; if a user wants to make changes to the contents of an
+ * \c Entity , every related \c EntityReference node
+ * has to be replaced in the structure model by a clone of the
+ * \c Entity 's contents, and then the desired changes must be
+ * made to each of those clones instead. All the descendants of an
+ * \c Entity node are readonly.
+ *
+ *  An \c Entity node does not have any parent.
+ *
+ */
+class KHTML_EXPORT Entity : public Node
+{
+public:
+    Entity();
+    Entity(const Entity &other);
+    Entity(const Node &other) : Node()
+         {(*this)=other;}
+
+    Entity & operator = (const Node &other);
+    Entity & operator = (const Entity &other);
+
+    ~Entity();
+
+    /**
+     * The public identifier associated with the entity, if specified.
+     * If the public identifier was not specified, this is \c null .
+     *
+     */
+    DOMString publicId() const;
+
+    /**
+     * The system identifier associated with the entity, if specified.
+     * If the system identifier was not specified, this is \c null .
+     *
+     */
+    DOMString systemId() const;
+
+    /**
+     * For unparsed entities, the name of the notation for the entity.
+     * For parsed entities, this is \c null .
+     *
+     */
+    DOMString notationName() const;
+protected:
+    Entity(EntityImpl *i);
+};
+
+
+/**
+ * \c EntityReference objects may be inserted into the
+ * structure model when an entity reference is in the source document,
+ * or when the user wishes to insert an entity reference. Note that
+ * character references and references to predefined entities are
+ * considered to be expanded by the HTML or XML processor so that
+ * characters are represented by their Unicode equivalent rather than
+ * by an entity reference. Moreover, the XML processor may completely
+ * expand references to entities while building the structure model,
+ * instead of providing \c EntityReference objects. If it
+ * does provide such objects, then for a given \c EntityReference
+ * node, it may be that there is no \c Entity node
+ * representing the referenced entity; but if such an \c Entity
+ * exists, then the child list of the \c EntityReference
+ * node is the same as that of the \c Entity node.
+ * As with the \c Entity node, all descendants of the
+ * \c EntityReference are readonly.
+ *
+ *  The resolution of the children of the \c EntityReference
+ * (the replacement value of the referenced \c Entity
+ * ) may be lazily evaluated; actions by the user (such as
+ * calling the \c childNodes method on the
+ * \c EntityReference node) are assumed to trigger the
+ * evaluation.
+ *
+ */
+class KHTML_EXPORT EntityReference : public Node
+{
+    friend class Document;
+public:
+    EntityReference();
+    EntityReference(const EntityReference &other);
+    EntityReference(const Node &other) : Node()
+         {(*this)=other;}
+
+    EntityReference & operator = (const Node &other);
+    EntityReference & operator = (const EntityReference &other);
+
+    ~EntityReference();
+protected:
+    EntityReference(EntityReferenceImpl *i);
+};
+
+class DOMString;
+
+/**
+ * This interface represents a notation declared in the DTD. A
+ * notation either declares, by name, the format of an unparsed entity
+ * (see section 4.7 of the XML 1.0 specification), or is used for
+ * formal declaration of Processing Instruction targets (see section
+ * 2.6 of the XML 1.0 specification). The \c nodeName
+ * attribute inherited from \c Node is set to the declared
+ * name of the notation.
+ *
+ *  The DOM Level 1 does not support editing \c Notation
+ * nodes; they are therefore readonly.
+ *
+ *  A \c Notation node does not have any parent.
+ *
+ */
+class KHTML_EXPORT Notation : public Node
+{
+public:
+    Notation();
+    Notation(const Notation &other);
+    Notation(const Node &other) : Node()
+         {(*this)=other;}
+
+    Notation & operator = (const Node &other);
+    Notation & operator = (const Notation &other);
+
+    ~Notation();
+
+    /**
+     * The public identifier of this notation. If the public
+     * identifier was not specified, this is \c null .
+     *
+     */
+    DOMString publicId() const;
+
+    /**
+     * The system identifier of this notation. If the system
+     * identifier was not specified, this is \c null .
+     *
+     */
+    DOMString systemId() const;
+protected:
+    Notation(NotationImpl *i);
+};
+
+
+/**
+ * The \c ProcessingInstruction interface represents a
+ * &quot;processing instruction&quot;, used in XML as a way to keep
+ * processor-specific information in the text of the document.
+ *
+ */
+class KHTML_EXPORT ProcessingInstruction : public Node
+{
+    friend class Document;
+public:
+    ProcessingInstruction();
+    ProcessingInstruction(const ProcessingInstruction &other);
+    ProcessingInstruction(const Node &other) : Node()
+         {(*this)=other;}
+
+    ProcessingInstruction & operator = (const Node &other);
+    ProcessingInstruction & operator = (const ProcessingInstruction &other);
+
+    ~ProcessingInstruction();
+
+    /**
+     * The target of this processing instruction. XML defines this as
+     * being the first token following the markup that begins the
+     * processing instruction.
+     *
+     */
+    DOMString target() const;
+
+    /**
+     * The content of this processing instruction. This is from the
+     * first non white space character after the target to the
+     * character immediately preceding the \c ?&gt; .
+     *
+     */
+    DOMString data() const;
+
+    /**
+     * see data
+     * @exception DOMException
+     * NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly.
+     *
+     */
+    void setData( const DOMString & );
+
+    /**
+     * Introduced in DOM Level 2
+     * This method is from the LinkStyle interface
+     *
+     * The style sheet.
+     */
+    StyleSheet sheet() const;
+
+protected:
+    ProcessingInstruction(ProcessingInstructionImpl *i);
+};
+
+} //namespace
+#endif