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

1 files changed, 443 insertions, 0 deletions

diff --git a/tdehtml/html/html_miscimpl.cpp b/tdehtml/html/html_miscimpl.cpp
new file mode 100644
index 000000000..58804bff5
--- /dev/null
+++ b/tdehtml/html/html_miscimpl.cpp
@@ -0,0 +1,443 @@
+/**
+ * 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) 2005 Maksim Orlovich (maksim@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.
+ *
+ */
+// -------------------------------------------------------------------------
+#include "html/html_tableimpl.h"
+#include "html/html_miscimpl.h"
+#include "html/html_formimpl.h"
+#include "html/html_documentimpl.h"
+
+#include "misc/htmlhashes.h"
+#include "dom/dom_node.h"
+
+using namespace DOM;
+
+#include <kdebug.h>
+
+HTMLBaseFontElementImpl::HTMLBaseFontElementImpl(DocumentImpl *doc)
+    : HTMLElementImpl(doc)
+{
+}
+
+HTMLBaseFontElementImpl::~HTMLBaseFontElementImpl()
+{
+}
+
+NodeImpl::Id HTMLBaseFontElementImpl::id() const
+{
+    return ID_BASEFONT;
+}
+
+// -------------------------------------------------------------------------
+
+struct CollectionCache: public NodeListImpl::Cache
+{
+    static Cache* make() { return new CollectionCache; }
+
+    TQDict<TQValueList<NodeImpl*> > nameCache;
+
+    CollectionCache(): nameCache(127)
+    {
+        nameCache.setAutoDelete(true);
+    }
+
+    virtual void clear(DocumentImpl* doc)
+    {
+        Cache::clear(doc);
+        //qDeletaAll here in Qt4
+        nameCache.clear();
+    }
+};
+
+HTMLCollectionImpl::HTMLCollectionImpl(NodeImpl *_base, int _type):
+    NodeListImpl(_base, _type, CollectionCache::make)
+{
+    type = _type;
+}
+
+bool HTMLCollectionImpl::nodeMatches(NodeImpl *current, bool& deep) const
+{
+    if ( current->nodeType() != Node::ELEMENT_NODE )
+    {
+        deep = false;
+        return false;
+    }
+
+    bool check = false;
+    HTMLElementImpl *e = static_cast<HTMLElementImpl *>(current);
+    switch(type)
+    {
+    case DOC_IMAGES:
+        if(e->id() == ID_IMG)
+            check = true;
+        break;
+    case DOC_SCRIPTS:
+        if(e->id() == ID_SCRIPT)
+            check = true;
+        break;
+    case DOC_FORMS:
+        if(e->id() == ID_FORM)
+            check = true;
+        break;
+    case DOC_LAYERS:
+        if(e->id() == ID_LAYER || e->id() == ID_ILAYER)
+            check = true;
+        break;
+    case TABLE_TBODIES:
+        if(e->id() == ID_TBODY)
+            check = true;
+        else if(e->id() == ID_TABLE)
+            deep = false;
+        break;
+    case TR_CELLS:
+        if(e->id() == ID_TD || e->id() == ID_TH)
+            check = true;
+        else if(e->id() == ID_TABLE)
+            deep = false;
+        break;
+    case TABLE_ROWS:
+    case TSECTION_ROWS:
+        if(e->id() == ID_TR)
+            check = true;
+        else if(e->id() == ID_TABLE)
+            deep = false;
+        break;
+    case SELECT_OPTIONS:
+        if(e->id() == ID_OPTION)
+            check = true;
+        break;
+    case MAP_AREAS:
+        if(e->id() == ID_AREA)
+            check = true;
+        break;
+    case DOC_APPLETS:   // all OBJECT and APPLET elements
+        if(e->id() == ID_OBJECT || e->id() == ID_APPLET || e->id() == ID_EMBED)
+            check = true;
+        break;
+    case DOC_LINKS:     // all A _and_ AREA elements with a value for href
+        if(e->id() == ID_A || e->id() == ID_AREA)
+            if(!e->getAttribute(ATTR_HREF).isNull())
+                check = true;
+        break;
+    case DOC_ANCHORS:      // all A elements with a value for name and/or id
+        if(e->id() == ID_A) {
+            if(e->hasID() || !e->getAttribute(ATTR_NAME).isNull())
+                check = true;
+        }
+        break;
+    case DOC_ALL:      // "all" elements
+        check = true;
+        break;
+    case NODE_CHILDREN: // first-level children
+        check = true;
+        deep = false;
+        break;
+    default:
+        kdDebug( 6030 ) << "Error in HTMLCollection, wrong tagId!" << endl;
+    }
+
+    return check;
+}
+
+bool HTMLCollectionImpl::checkForNameMatch(NodeImpl *node, const DOMString &name) const
+{
+    if ( node->nodeType() != Node::ELEMENT_NODE )
+        return false;
+
+    HTMLElementImpl *e = static_cast<HTMLElementImpl *>(node);
+
+    //If ID matches, this is definitely a match
+    if (e->getAttribute(ATTR_ID) == name)
+        return true;
+
+    //Despite what the DOM spec says, neither IE nor Gecko actually
+    //care to prefer IDs. Instead, they just match everything
+    //that has ID or a name for nodes that have a name.
+    //Except for the form elements collection, Gecko always returns
+    //just one item. IE is more complex: its namedItem
+    //and call notation access return everything that matches,
+    //but the subscript notation is sometimes different.
+    //For now, we try to match IE, but without the subscript
+    //oddness, which I don't understand -- Maks.
+
+    bool checkName;
+    switch (e->id())
+    {
+        case ID_A:
+        case ID_APPLET:
+        case ID_BUTTON:
+        case ID_EMBED:
+        case ID_FORM:
+        case ID_IMG:
+        case ID_INPUT:
+        case ID_MAP:
+        case ID_META:
+        case ID_OBJECT:
+        case ID_SELECT:
+        case ID_TEXTAREA:
+        case ID_FRAME:
+        case ID_IFRAME:
+        case ID_FRAMESET:
+            checkName = true;
+            break;
+        default:
+            checkName = false;
+    }
+
+    if (checkName)
+       return e->getAttribute(ATTR_NAME) == name;
+    else
+       return false;
+}
+
+NodeImpl *HTMLCollectionImpl::item ( unsigned long index ) const
+{
+    //Most of the time, we just go in normal document order
+    if (type != TABLE_ROWS)
+        return NodeListImpl::item(index);
+
+    //For table.rows, we first need to check header, then bodies, then footer.
+    //we pack any extra headers/footer with bodies. This matches IE, and
+    //means doing the usual thing with length is right
+    const HTMLTableElementImpl* table = static_cast<const HTMLTableElementImpl*>(m_refNode);
+
+    long                          sectionIndex;
+    HTMLTableSectionElementImpl*  section;
+
+    NodeImpl* found = 0;
+    if (table->findRowSection(index, section, sectionIndex)) {
+        HTMLCollectionImpl rows(section, TSECTION_ROWS);
+        found = rows.item(sectionIndex);
+    }
+
+    m_cache->current.node = found; //namedItem needs this.
+    m_cache->position     = index;
+    return found;
+}
+
+unsigned long HTMLCollectionImpl::calcLength(NodeImpl *start) const
+{
+    if (type != TABLE_ROWS)
+        return NodeListImpl::calcLength(start);
+
+    unsigned length = 0;
+    const HTMLTableElementImpl* table = static_cast<const HTMLTableElementImpl*>(m_refNode);
+    for (NodeImpl* kid = table->firstChild(); kid; kid = kid->nextSibling()) {
+        HTMLCollectionImpl rows(kid, TSECTION_ROWS);
+        length += rows.length();
+    }
+    return length;
+}
+
+NodeImpl *HTMLCollectionImpl::firstItem() const
+{
+    return item(0);
+}
+
+NodeImpl *HTMLCollectionImpl::nextItem() const
+{
+    //### this assumes this is called immediately after nextItem --
+    //it this sane?
+    return item(m_cache->position + 1);
+}
+
+NodeImpl *HTMLCollectionImpl::namedItem( const DOMString &name ) const
+{
+    //Reset the position. The invariant is that nextNamedItem will start looking
+    //from the current position.
+    firstItem();
+
+    return nextNamedItem(name);
+}
+
+NodeImpl *HTMLCollectionImpl::nextNamedItem( const DOMString &name ) const
+{
+    while (NodeImpl* candidate = m_cache->current.node)
+    {
+        //Always advance, for next call
+        nextItem();
+        if (checkForNameMatch(candidate, name))
+            return candidate;
+    }
+    return 0;
+}
+
+TQValueList<NodeImpl*> HTMLCollectionImpl::namedItems( const DOMString &name ) const
+{
+    TQString key = name.string();
+
+    //We use a work-conserving design for the name cache presently -- only
+    //remember stuff about elements we were asked for.
+    m_cache->updateNodeListInfo(m_refNode->getDocument());
+    CollectionCache* cache = static_cast<CollectionCache*>(m_cache);
+    if (TQValueList<NodeImpl*>* info = cache->nameCache.find(key)) {
+        return *info;
+    }
+    else {
+        TQValueList<NodeImpl*>* newInfo = new TQValueList<NodeImpl*>;
+
+        NodeImpl* match = namedItem(name);
+        while (match) {
+            newInfo->append(match);
+            match = nextNamedItem(name);
+        }
+
+        cache->nameCache.insert(key, newInfo);
+        return *newInfo;
+    }
+}
+
+// -----------------------------------------------------------------------------
+
+HTMLFormCollectionImpl::HTMLFormCollectionImpl(NodeImpl* _base)
+    : HTMLCollectionImpl(_base, FORM_ELEMENTS), currentNamePos(0), currentNameImgPos(0)
+{}
+
+NodeImpl *HTMLFormCollectionImpl::item( unsigned long index ) const
+{
+    m_cache->updateNodeListInfo(m_refNode->getDocument());
+
+    unsigned int dist = index;
+    unsigned int strt = 0;
+    if (m_cache->current.index && m_cache->position <= index)
+    {
+        dist = index - m_cache->position;
+        strt = m_cache->current.index;
+    }
+
+    TQPtrList<HTMLGenericFormElementImpl>& l = static_cast<HTMLFormElementImpl*>( m_refNode )->formElements;
+    for (unsigned i = strt; i < l.count(); i++)
+    {
+        if (l.at( i )->isEnumeratable())
+        {
+            if (dist == 0)
+            {
+                //Found it!
+                m_cache->position      = index;
+                m_cache->current.index = i;
+                return l.at( i );
+            }
+            else
+                --dist;
+        }
+    }
+    return 0;
+}
+
+unsigned long HTMLFormCollectionImpl::calcLength(NodeImpl *start) const
+{
+    unsigned length = 0;
+    TQPtrList<HTMLGenericFormElementImpl> l = static_cast<HTMLFormElementImpl*>( start )->formElements;
+    for ( unsigned i = 0; i < l.count(); i++ )
+        if ( l.at( i )->isEnumeratable() )
+            ++length;
+    return length;
+}
+
+NodeImpl *HTMLFormCollectionImpl::namedItem( const DOMString &name ) const
+{
+    currentNamePos    = 0;
+    currentNameImgPos = 0;
+    foundInput        = false;
+    return nextNamedItem(name);
+}
+
+NodeImpl *HTMLFormCollectionImpl::nextNamedItem( const DOMString &name ) const
+{
+    TQPtrList<HTMLGenericFormElementImpl>& l = static_cast<HTMLFormElementImpl*>( m_refNode )->formElements;
+
+    //Go through the list, trying to find the appropriate named form element.
+    for ( ; currentNamePos < l.count(); ++currentNamePos )
+    {
+        HTMLGenericFormElementImpl* el = l.at(currentNamePos);
+        if (el->isEnumeratable() &&
+             ((el->getAttribute(ATTR_ID)   == name) ||
+              (el->getAttribute(ATTR_NAME) == name)))
+        {
+            ++currentNamePos; //Make next call start after this
+            foundInput = true;//No need to look for img
+            return el;
+        }
+    }
+
+    //If we got this far, we may need to start looking through the images,
+    //but only if no input tags were matched
+    if (foundInput) return 0;
+
+    TQPtrList<HTMLImageElementImpl>& il = static_cast<HTMLFormElementImpl*>( m_refNode )->imgElements;
+    for ( ; currentNameImgPos < il.count(); ++currentNameImgPos )
+    {
+        HTMLImageElementImpl* el = il.at(currentNameImgPos);
+        if ((el->getAttribute(ATTR_ID)   == name) ||
+            (el->getAttribute(ATTR_NAME) == name))
+        {
+            ++currentNameImgPos; //Make next call start after this
+            return el;
+        }
+    }
+
+    return 0;
+}
+
+// -------------------------------------------------------------------------
+HTMLMappedNameCollectionImpl::HTMLMappedNameCollectionImpl(NodeImpl* _base, int _type, const DOMString& _name):
+    HTMLCollectionImpl(_base, NodeListImpl::UNCACHEABLE), name(_name)
+{
+    type = _type; //We pass uncacheable to collection, but need our own type internally.
+}
+
+bool HTMLMappedNameCollectionImpl::nodeMatches(NodeImpl *current, bool& deep) const
+{
+    if ( current->nodeType() != Node::ELEMENT_NODE )
+    {
+        deep = false;
+        return false;
+    }
+
+    HTMLElementImpl *e = static_cast<HTMLElementImpl *>(current);
+
+    return matchesName(e, type, name);
+}
+
+bool HTMLMappedNameCollectionImpl::matchesName( ElementImpl* el, int type, const DOMString& name )
+{
+    switch (el->id())
+    {
+    case ID_IMG:
+    case ID_FORM:
+        //Under document. these require non-empty name to see the element
+        if (type == DOCUMENT_NAMED_ITEMS && el->getAttribute(ATTR_NAME).isNull())
+            return false;
+        //Otherwise, fallthrough
+    case ID_OBJECT:
+    case ID_EMBED:
+    case ID_APPLET:
+    case ID_LAYER:
+        if (el->getAttribute(ATTR_NAME) == name || el->getAttribute(ATTR_ID) == name)
+            return true;
+        else
+            return false;
+    default:
+        return false;
+    }
+}