Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdelibs@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 649 insertions, 0 deletions

diff --git a/khtml/html/html_headimpl.cpp b/khtml/html/html_headimpl.cpp
new file mode 100644
index 000000000..6808f27bf
--- /dev/null
+++ b/khtml/html/html_headimpl.cpp
@@ -0,0 +1,649 @@
+/**
+ * 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 Dirk Mueller (mueller@kde.org)
+ *           (C) 2002-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.
+ */
+// -------------------------------------------------------------------------
+
+#include "html/html_headimpl.h"
+#include "html/html_documentimpl.h"
+#include "xml/dom_textimpl.h"
+
+#include "khtmlview.h"
+#include "khtml_part.h"
+
+#include "misc/htmlhashes.h"
+#include "misc/loader.h"
+#include "misc/helper.h"
+
+#include "css/cssstyleselector.h"
+#include "css/css_stylesheetimpl.h"
+#include "css/csshelper.h"
+
+#include "ecma/kjs_proxy.h"
+
+#include <kurl.h>
+#include <kdebug.h>
+
+using namespace khtml;
+
+NodeImpl::Id HTMLBaseElementImpl::id() const
+{
+    return ID_BASE;
+}
+
+void HTMLBaseElementImpl::parseAttribute(AttributeImpl *attr)
+{
+    switch(attr->id())
+    {
+    case ATTR_HREF:
+	m_href = khtml::parseURL(attr->value());
+	process();
+	break;
+    case ATTR_TARGET:
+	m_target = attr->value();
+	process();
+	break;
+    default:
+        HTMLElementImpl::parseAttribute(attr);
+    }
+}
+
+void HTMLBaseElementImpl::insertedIntoDocument()
+{
+    HTMLElementImpl::insertedIntoDocument();
+    process();
+}
+
+void HTMLBaseElementImpl::removedFromDocument()
+{
+    HTMLElementImpl::removedFromDocument();
+
+    // Since the document doesn't have a base element...
+    // (This will break in the case of multiple base elements, but that's not valid anyway (?))
+    getDocument()->setBaseURL( KURL() );
+    getDocument()->setBaseTarget( QString::null );
+}
+
+void HTMLBaseElementImpl::process()
+{
+    if (!inDocument())
+	return;
+
+    if(!m_href.isEmpty() && getDocument()->view())
+	getDocument()->setBaseURL( KURL( getDocument()->view()->part()->url(), m_href.string() ) );
+
+    if(!m_target.isEmpty())
+	getDocument()->setBaseTarget( m_target.string() );
+
+    // ### should changing a document's base URL dynamically automatically update all images, stylesheets etc?
+}
+
+// -------------------------------------------------------------------------
+
+
+HTMLLinkElementImpl::~HTMLLinkElementImpl()
+{
+    if(m_sheet) m_sheet->deref();
+    if(m_cachedSheet) m_cachedSheet->deref(this);
+}
+
+NodeImpl::Id HTMLLinkElementImpl::id() const
+{
+    return ID_LINK;
+}
+
+void HTMLLinkElementImpl::parseAttribute(AttributeImpl *attr)
+{
+    switch (attr->id())
+    {
+    case ATTR_HREF:
+        m_url = getDocument()->completeURL( khtml::parseURL(attr->value()).string() );
+	process();
+        break;
+    case ATTR_REL:
+    case ATTR_TYPE:
+	process();
+        break;
+    case ATTR_TITLE:
+        // ### when title changes we have to reconsider our alternative
+        // stylesheet choice
+        break;
+    case ATTR_MEDIA:
+        m_media = attr->value().string().lower();
+        process();
+        break;
+    case ATTR_DISABLED: {
+        bool m_oldisDisabled = m_isDisabled;
+        m_isDisabled = attr->val();
+        if (m_oldisDisabled != m_isDisabled) {
+            if (isLoading()) {
+                if (m_oldisDisabled)
+                    getDocument()->addPendingSheet();
+                else if (!m_alternate)
+                    getDocument()->styleSheetLoaded();
+            }
+            if (m_oldisDisabled) {
+                // enabling: if it's an alternate sheet, pretend it's not.
+                m_alternate = false;
+            } else if (!m_alternate) {
+                // disabling: recheck alternate status
+                QString rel =  getAttribute(ATTR_REL).string().lower();
+                QString type = getAttribute(ATTR_TYPE).string().lower();
+                m_alternate = (type.contains("text/css") || rel.contains("stylesheet")) && rel.contains("alternate");
+            }
+            if (isLoading())
+                break;
+            if (!m_sheet && !m_isDisabled) {
+                process();
+                if (isLoading() && m_alternate)
+                    getDocument()->addPendingSheet();
+                m_alternate = false;
+            } else
+                getDocument()->updateStyleSelector(); // Update the style selector.
+        }
+        break;
+    }
+    default:
+        HTMLElementImpl::parseAttribute(attr);
+    }
+}
+
+void HTMLLinkElementImpl::process()
+{
+    if (!inDocument())
+        return;
+
+    QString type = getAttribute(ATTR_TYPE).string().lower();
+    QString rel = getAttribute(ATTR_REL).string().lower();
+
+    KHTMLPart* part = getDocument()->view() ? getDocument()->view()->part() : 0;
+
+    // IE extension: location of small icon for locationbar / bookmarks
+    // Uses both "shortcut icon" and "icon"
+    if ( part && rel.contains("icon") && !m_url.isEmpty() && !part->parentPart())
+        part->browserExtension()->setIconURL( KURL(m_url.string()) );
+
+    // Stylesheet
+    else if (!m_isDisabled &&
+        (type.contains("text/css") || rel.contains("stylesheet"))) {
+        // no need to load style sheets which aren't for the screen output
+        // ### there may be in some situations e.g. for an editor or script to manipulate
+        if( m_media.isNull() || m_media.contains("screen") || m_media.contains("all") || m_media.contains("print") ) {
+            m_loading = true;
+            // Add ourselves as a pending sheet, but only if we aren't an alternate
+            // stylesheet.  Alternate stylesheets don't hold up render tree construction.
+            m_alternate = rel.contains("alternate");
+            if (!isAlternate())
+                getDocument()->addPendingSheet();
+
+            QString chset = getAttribute( ATTR_CHARSET ).string();
+            // set chset to charset of referring document when attribute CHARSET is absent.
+            // http://www.w3.org/TR/CSS21/syndata.html(4.4)
+            if (chset.isEmpty() && part) chset = part->encoding();
+            if (m_cachedSheet)
+		m_cachedSheet->deref(this);
+            m_cachedSheet = getDocument()->docLoader()->requestStyleSheet(m_url, chset);
+            if (m_cachedSheet) {
+                m_isCSSSheet = true;
+		m_cachedSheet->ref(this);
+            }
+            else if (!isAlternate()) {
+                // Error requesting sheet; decrement pending sheet count
+                getDocument()->styleSheetLoaded();
+            }
+        }
+    }
+    else if (m_sheet) {
+	// we no longer contain a stylesheet, e.g. perhaps rel or type was changed
+	m_sheet->deref();
+	m_sheet = 0;
+        m_isCSSSheet = false;
+	getDocument()->updateStyleSelector();
+    }
+}
+
+void HTMLLinkElementImpl::insertedIntoDocument()
+{
+    HTMLElementImpl::insertedIntoDocument();
+    process();
+}
+
+void HTMLLinkElementImpl::removedFromDocument()
+{
+    HTMLElementImpl::removedFromDocument();
+    getDocument()->updateStyleSelector();
+}
+
+void HTMLLinkElementImpl::setStyleSheet(const DOM::DOMString &url, const DOM::DOMString &sheetStr, const DOM::DOMString &charset)
+{
+    if (m_sheet)
+        m_sheet->deref();
+    m_sheet = new CSSStyleSheetImpl(this, url);
+    m_sheet->ref();
+    m_sheet->setCharset(charset);
+    m_sheet->parseString( sheetStr, !getDocument()->inCompatMode() );
+
+    MediaListImpl *media = new MediaListImpl( m_sheet, m_media );
+    m_sheet->setMedia( media );
+
+    finished();
+}
+
+void HTMLLinkElementImpl::finished()
+{
+    m_loading = false;
+
+    // Tell the doc about the sheet.
+    if (!isLoading() && !isDisabled() && !isAlternate())
+        getDocument()->styleSheetLoaded();
+
+    // ### major inefficiency, but currently necessary for proper
+    // alternate styles support. don't recalc the styleselector
+    // when nothing actually changed!
+    if ( isAlternate() && m_sheet && !isDisabled())
+        getDocument()->updateStyleSelector();
+}
+
+void HTMLLinkElementImpl::error( int, const QString& )
+{
+    finished();
+}
+
+bool HTMLLinkElementImpl::isLoading() const
+{
+//    kdDebug( 6030 ) << "link: checking if loading!" << endl;
+    if(m_loading) return true;
+    if(!m_sheet) return false;
+    //if(!m_sheet->isCSSStyleSheet()) return false;
+    return static_cast<CSSStyleSheetImpl *>(m_sheet)->isLoading();
+}
+
+void HTMLLinkElementImpl::sheetLoaded()
+{
+    if (!isLoading() && !isDisabled() && !isAlternate())
+        getDocument()->styleSheetLoaded();
+}
+
+// -------------------------------------------------------------------------
+
+NodeImpl::Id HTMLMetaElementImpl::id() const
+{
+    return ID_META;
+}
+
+void HTMLMetaElementImpl::parseAttribute(AttributeImpl *attr)
+{
+    switch(attr->id())
+    {
+    case ATTR_HTTP_EQUIV:
+	m_equiv = attr->value();
+	process();
+	break;
+    case ATTR_CONTENT:
+	m_content = attr->value();
+	process();
+	break;
+    default:
+        HTMLElementImpl::parseAttribute(attr);
+    }
+}
+
+void HTMLMetaElementImpl::insertedIntoDocument()
+{
+    HTMLElementImpl::insertedIntoDocument();
+    process();
+}
+
+void HTMLMetaElementImpl::process()
+{
+    // Get the document to process the tag, but only if we're actually part of DOM tree (changing a meta tag while
+    // it's not in the tree shouldn't have any effect on the document)
+    if (inDocument() && !m_equiv.isNull() && !m_content.isNull())
+	getDocument()->processHttpEquiv(m_equiv,m_content);
+}
+
+// -------------------------------------------------------------------------
+
+HTMLScriptElementImpl::HTMLScriptElementImpl(DocumentImpl *doc)
+    : HTMLElementImpl(doc), m_cachedScript(0), m_createdByParser(false), m_evaluated(false)
+{
+}
+
+HTMLScriptElementImpl::~HTMLScriptElementImpl()
+{
+    if (m_cachedScript)
+        m_cachedScript->deref(this);
+}
+
+NodeImpl::Id HTMLScriptElementImpl::id() const
+{
+    return ID_SCRIPT;
+}
+
+bool HTMLScriptElementImpl::isURLAttribute(AttributeImpl *attr) const
+{
+    return attr->id() == ATTR_SRC;
+}
+
+void HTMLScriptElementImpl::childrenChanged()
+{
+    // If a node is inserted as a child of the script element
+    // and the script element has been inserted in the document
+    // we evaluate the script.
+    if (!m_createdByParser && inDocument() && firstChild())
+        evaluateScript(getDocument()->URL().url(), text());
+}
+
+void HTMLScriptElementImpl::insertedIntoDocument()
+{
+    HTMLElementImpl::insertedIntoDocument();
+
+    assert(!m_cachedScript);
+
+    if (m_createdByParser)
+        return;
+
+    QString url = getAttribute(ATTR_SRC).string();
+    if (!url.isEmpty()) {
+        QString charset = getAttribute(ATTR_CHARSET).string();
+        m_cachedScript = getDocument()->docLoader()->requestScript(DOMString(url), charset);
+        if (m_cachedScript)
+            m_cachedScript->ref(this);
+        return;
+    }
+
+    // If there's an empty script node, we shouldn't evaluate the script
+    // because if a script is inserted afterwards (by setting text or innerText)
+    // it should be evaluated, and evaluateScript only evaluates a script once.
+    DOMString scriptString = text();
+    if (!scriptString.isEmpty())
+        evaluateScript(getDocument()->URL().url(), scriptString);
+}
+
+void HTMLScriptElementImpl::removedFromDocument()
+{
+    HTMLElementImpl::removedFromDocument();
+
+    if (m_cachedScript) {
+        m_cachedScript->deref(this);
+        m_cachedScript = 0;
+    }
+}
+
+void HTMLScriptElementImpl::notifyFinished(CachedObject* o)
+{
+    CachedScript *cs = static_cast<CachedScript *>(o);
+
+    assert(cs == m_cachedScript);
+
+    QString   URL    = cs->url().string();
+    DOMString script = cs->script();
+    cs->deref(this);
+    m_cachedScript = 0;
+
+    evaluateScript(URL, script);
+}
+
+void HTMLScriptElementImpl::evaluateScript(const QString &URL, const DOMString &script)
+{
+    if (m_evaluated)
+        return;
+
+    KHTMLPart *part = getDocument()->part();
+    if (part) {
+        KJSProxy *proxy = KJSProxy::proxy(part);
+        if (proxy) {
+            m_evaluated = true;
+            proxy->evaluate(URL, 0, script.string(), 0);
+            DocumentImpl::updateDocumentsRendering();
+        }
+    }
+}
+
+DOMString HTMLScriptElementImpl::text() const
+{
+    DOMString val = "";
+
+    for (NodeImpl *n = firstChild(); n; n = n->nextSibling()) {
+        if (n->isTextNode())
+            val += static_cast<TextImpl *>(n)->data();
+    }
+
+    return val;
+}
+
+void HTMLScriptElementImpl::setText(const DOMString &value)
+{
+    int exceptioncode = 0;
+    int numChildren = childNodeCount();
+
+    if (numChildren == 1 && firstChild()->isTextNode()) {
+        static_cast<DOM::TextImpl *>(firstChild())->setData(value, exceptioncode);
+        return;
+    }
+
+    if (numChildren > 0) {
+        removeChildren();
+    }
+
+    appendChild(getDocument()->createTextNode(value.implementation()), exceptioncode);
+}
+
+DOMString HTMLScriptElementImpl::htmlFor() const
+{
+    // DOM Level 1 says: reserved for future use.
+    return DOMString();
+}
+
+void HTMLScriptElementImpl::setHtmlFor(const DOMString &/*value*/)
+{
+    // DOM Level 1 says: reserved for future use.
+}
+
+DOMString HTMLScriptElementImpl::event() const
+{
+    // DOM Level 1 says: reserved for future use.
+    return DOMString();
+}
+
+void HTMLScriptElementImpl::setEvent(const DOMString &/*value*/)
+{
+    // DOM Level 1 says: reserved for future use.
+}
+
+DOMString HTMLScriptElementImpl::charset() const
+{
+    return getAttribute(ATTR_CHARSET);
+}
+
+void HTMLScriptElementImpl::setCharset(const DOMString &value)
+{
+    setAttribute(ATTR_CHARSET, value);
+}
+
+bool HTMLScriptElementImpl::defer() const
+{
+    return !getAttribute(ATTR_DEFER).isNull();
+}
+
+void HTMLScriptElementImpl::setDefer(bool defer)
+{
+    setAttribute(ATTR_DEFER, defer ? "" : 0);
+}
+
+DOMString HTMLScriptElementImpl::src() const
+{
+    return getDocument()->completeURL(getAttribute(ATTR_SRC).string());
+}
+
+void HTMLScriptElementImpl::setSrc(const DOMString &value)
+{
+    setAttribute(ATTR_SRC, value);
+}
+
+DOMString HTMLScriptElementImpl::type() const
+{
+    return getAttribute(ATTR_TYPE);
+}
+
+void HTMLScriptElementImpl::setType(const DOMString &value)
+{
+    setAttribute(ATTR_TYPE, value);
+}
+
+// -------------------------------------------------------------------------
+
+HTMLStyleElementImpl::~HTMLStyleElementImpl()
+{
+    if(m_sheet) m_sheet->deref();
+}
+
+NodeImpl::Id HTMLStyleElementImpl::id() const
+{
+    return ID_STYLE;
+}
+
+// other stuff...
+void HTMLStyleElementImpl::parseAttribute(AttributeImpl *attr)
+{
+    switch (attr->id())
+    {
+    case ATTR_TYPE:
+        m_type = attr->value().lower();
+        break;
+    case ATTR_MEDIA:
+        m_media = attr->value().string().lower();
+        break;
+    default:
+        HTMLElementImpl::parseAttribute(attr);
+    }
+}
+
+void HTMLStyleElementImpl::insertedIntoDocument()
+{
+    HTMLElementImpl::insertedIntoDocument();
+    if (m_sheet)
+        getDocument()->updateStyleSelector();
+}
+
+void HTMLStyleElementImpl::removedFromDocument()
+{
+    HTMLElementImpl::removedFromDocument();
+    if (m_sheet)
+        getDocument()->updateStyleSelector();
+}
+
+void HTMLStyleElementImpl::childrenChanged()
+{
+    HTMLElementImpl::childrenChanged();
+
+    DOMString text = "";
+
+    for (NodeImpl *c = firstChild(); c != 0; c = c->nextSibling()) {
+	if ((c->nodeType() == Node::TEXT_NODE) ||
+	    (c->nodeType() == Node::CDATA_SECTION_NODE) ||
+	    (c->nodeType() == Node::COMMENT_NODE))
+	    text += c->nodeValue();
+    }
+
+    if (m_sheet) {
+        m_sheet->deref();
+        m_sheet = 0;
+    }
+
+    m_loading = false;
+    if ((m_type.isEmpty() || m_type == "text/css") // Type must be empty or CSS
+         && (m_media.isNull() || m_media.contains("screen") || m_media.contains("all") || m_media.contains("print"))) {
+        getDocument()->addPendingSheet();
+        m_loading = true;
+        m_sheet = new CSSStyleSheetImpl(this);
+        m_sheet->ref();
+        m_sheet->parseString( text, !getDocument()->inCompatMode() );
+        MediaListImpl* media = new MediaListImpl( m_sheet, DOMString( m_media ) );
+        m_sheet->setMedia( media );
+        m_loading = false;
+    }
+
+    if (!isLoading() && m_sheet)
+        getDocument()->styleSheetLoaded();
+}
+
+bool HTMLStyleElementImpl::isLoading() const
+{
+    if (m_loading) return true;
+    if(!m_sheet) return false;
+    return static_cast<CSSStyleSheetImpl *>(m_sheet)->isLoading();
+}
+
+void HTMLStyleElementImpl::sheetLoaded()
+{
+    if (!isLoading())
+        getDocument()->styleSheetLoaded();
+}
+
+// -------------------------------------------------------------------------
+
+NodeImpl::Id HTMLTitleElementImpl::id() const
+{
+    return ID_TITLE;
+}
+
+void HTMLTitleElementImpl::childrenChanged()
+{
+    HTMLElementImpl::childrenChanged();
+
+    m_title = "";
+    for (NodeImpl *c = firstChild(); c != 0; c = c->nextSibling()) {
+	if ((c->nodeType() == Node::TEXT_NODE) || (c->nodeType() == Node::CDATA_SECTION_NODE))
+	    m_title += c->nodeValue();
+    }
+    if ( !m_title.isEmpty() && inDocument())
+        getDocument()->setTitle(m_title);
+}
+
+DOMString HTMLTitleElementImpl::text()
+{
+    if (firstChild() && firstChild()->nodeType() == Node::TEXT_NODE) {
+        return firstChild()->nodeValue();
+    }
+    return "";
+}
+
+void HTMLTitleElementImpl::setText( const DOMString& str )
+{
+    int exceptioncode = 0;
+    // Look for an existing text child node
+    DOM::NodeListImpl* nl(childNodes());
+    if (nl)
+    {
+        for (unsigned int i = 0; i < nl->length(); i++) {
+            if (nl->item(i)->nodeType() == DOM::Node::TEXT_NODE) {
+                static_cast<DOM::TextImpl *>(nl->item(i))->setData(str, exceptioncode);
+                return;
+            }
+        }
+        delete nl;
+    }
+    // No child text node found, creating one
+    DOM::TextImpl* t = getDocument()->createTextNode(str.implementation());
+    appendChild(t, exceptioncode);
+}