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

35 files changed, 21800 insertions, 0 deletions

diff --git a/tdehtml/css/CMakeLists.txt b/tdehtml/css/CMakeLists.txt
new file mode 100644
index 000000000..4d0b52df1
--- /dev/null
+++ b/tdehtml/css/CMakeLists.txt
@@ -0,0 +1,47 @@
+#################################################
+#
+#  (C) 2010 Serghei Amelian
+#  serghei (DOT) amelian (AT) gmail.com
+#
+#  Improvements and feedback are welcome
+#
+#  This file is released under GPL >= 2
+#
+#################################################
+
+include_directories(
+  ${TQT_INCLUDE_DIRS}
+  ${CMAKE_CURRENT_BINARY_DIR}
+  ${CMAKE_BINARY_DIR}
+  ${CMAKE_BINARY_DIR}/tdecore
+  ${CMAKE_SOURCE_DIR}
+  ${CMAKE_SOURCE_DIR}/tdehtml
+  ${CMAKE_SOURCE_DIR}/dcop
+  ${CMAKE_SOURCE_DIR}/tdecore
+  ${CMAKE_SOURCE_DIR}/tdeui
+  ${CMAKE_SOURCE_DIR}/kio
+  ${CMAKE_SOURCE_DIR}/kio/kio
+  ${CMAKE_SOURCE_DIR}/tdewallet/client
+  ${CMAKE_SOURCE_DIR}/tdeutils
+)
+
+
+##### other data ################################
+
+install( FILES html4.css quirks.css DESTINATION ${DATA_INSTALL_DIR}/tdehtml/css )
+
+
+##### tdehtmlcss (static) #########################
+
+set( target tdehtmlcss )
+
+set( ${target}_SRCS
+  css_stylesheetimpl.cpp css_ruleimpl.cpp css_valueimpl.cpp
+  css_base.cpp cssparser.cpp cssstyleselector.cpp
+  csshelper.cpp parser.cpp css_renderstyledeclarationimpl.cpp
+)
+
+tde_add_library( ${target} STATIC_PIC AUTOMOC
+  SOURCES ${${target}_SRCS}
+)
+
diff --git a/tdehtml/css/Makefile.am b/tdehtml/css/Makefile.am
new file mode 100644
index 000000000..6c43675ed
--- /dev/null
+++ b/tdehtml/css/Makefile.am
@@ -0,0 +1,60 @@
+#    This file is part of the KDE libraries
+#    Copyright (C) 1997 Martin Jones (mjones@kde.org)
+#              (C) 1997 Torben Weis (weis@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.
+
+KDE_CXXFLAGS = $(WOVERLOADED_VIRTUAL) 
+
+YACC=bison
+
+noinst_LTLIBRARIES = libtdehtmlcss.la
+libtdehtmlcss_la_SOURCES = \
+	css_stylesheetimpl.cpp css_ruleimpl.cpp css_valueimpl.cpp css_base.cpp \
+	cssparser.cpp cssstyleselector.cpp csshelper.cpp parser.cpp \
+	css_renderstyledeclarationimpl.cpp
+
+#libtdehtmlcss_la_LDFLAGS = -no-undefined 
+libtdehtmlcss_la_METASOURCES = AUTO
+
+noinst_HEADERS = \
+	css_extensionsimpl.h  css_stylesheetimpl.h  cssparser.h \
+	css_ruleimpl.h css_valueimpl.h css_base.h \
+	cssstyleselector.h csshelper.h parser.h   \
+	css_renderstyledeclarationimpl.h
+
+INCLUDES = -I$(top_srcdir)/kimgio -I$(top_srcdir)/kio -I$(top_srcdir)/dcop \
+ -I$(top_srcdir)/tdehtml -I$(top_srcdir)/libltdl -I$(top_srcdir) \
+ -I$(top_srcdir)/tdewallet/client -I$(top_srcdir)/tdeutils \
+ $(all_includes)
+
+cssdir = $(kde_datadir)/tdehtml/css
+css_DATA = html4.css quirks.css
+
+SRCDOC_DEST=$(kde_htmldir)/en/tdelibs/tdehtml
+
+EXTRA_DIST = parser.y
+
+parser: $(srcdir)/parser.y
+	cd $(srcdir); \
+	$(YACC) -v -d -p cssyy parser.y && mv parser.tab.c parser.cpp; \
+	if test -f parser.tab.h; then \
+	if cmp -s parser.tab.h parser.h; then rm -f parser.tab.h; \
+	else mv parser.tab.h parser.h; fi \
+	else :; fi
+
+.PHONY: parser 
+
diff --git a/tdehtml/css/css_base.cpp b/tdehtml/css/css_base.cpp
new file mode 100644
index 000000000..a4dda95a0
--- /dev/null
+++ b/tdehtml/css/css_base.cpp
@@ -0,0 +1,419 @@
+/*
+ * This file is part of the DOM implementation for KDE.
+ *
+ * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org)
+ *               1999 Waldo Bastian (bastian@kde.org)
+ *               2001 Andreas Schlapbach (schlpbch@iam.unibe.ch)
+ *               2001-2003 Dirk Mueller (mueller@kde.org)
+ *               2002 Apple Computer, Inc.
+ *               2004 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 CSS_DEBUG
+
+#include <assert.h>
+#include <kdebug.h>
+
+#include "css_base.h"
+
+#ifdef CSS_DEBUG
+#include "cssproperties.h"
+#endif
+
+#include "css_stylesheetimpl.h"
+#include "xml/dom_docimpl.h"
+#include "misc/htmlhashes.h"
+#include "css_valueimpl.h"
+using namespace DOM;
+
+void StyleBaseImpl::checkLoaded() const
+{
+    if(m_parent) m_parent->checkLoaded();
+}
+
+StyleSheetImpl* StyleBaseImpl::stylesheet()
+{
+    StyleBaseImpl* b = this;
+    while(b && !b->isStyleSheet())
+        b = b->m_parent;
+    return static_cast<StyleSheetImpl *>(b);
+}
+
+KURL StyleBaseImpl::baseURL()
+{
+    // try to find the style sheet. If found look for its url.
+    // If it has none, look for the parentsheet, or the parentNode and
+    // try to find out about their url
+
+    StyleSheetImpl *sheet = stylesheet();
+
+    if(!sheet) return KURL();
+
+    if(!sheet->href().isNull())
+        return KURL( sheet->href().string() );
+
+    // find parent
+    if(sheet->parent()) return sheet->parent()->baseURL();
+
+    if(!sheet->ownerNode()) return KURL();
+
+    return sheet->ownerNode()->getDocument()->baseURL();
+}
+
+void StyleBaseImpl::setParsedValue(int propId, const CSSValueImpl *parsedValue,
+				   bool important, bool nonCSSHint, TQPtrList<CSSProperty> *propList)
+{
+    TQPtrListIterator<CSSProperty> propIt(*propList);
+    propIt.toLast(); // just remove the top one - not sure what should happen if we have multiple instances of the property
+    while (propIt.current() &&
+           ( propIt.current()->m_id != propId || propIt.current()->nonCSSHint != nonCSSHint ||
+             propIt.current()->m_important != important) )
+        --propIt;
+    if (propIt.current())
+        propList->removeRef(propIt.current());
+
+    CSSProperty *prop = new CSSProperty();
+    prop->m_id = propId;
+    prop->setValue((CSSValueImpl *) parsedValue);
+    prop->m_important = important;
+    prop->nonCSSHint = nonCSSHint;
+
+    propList->append(prop);
+#ifdef CSS_DEBUG
+    kdDebug( 6080 ) << "added property: " << getPropertyName(propId).string()
+                    // non implemented yet << ", value: " << parsedValue->cssText().string()
+                    << " important: " << prop->m_important
+                    << " nonCSS: " << prop->nonCSSHint << endl;
+#endif
+}
+
+// ------------------------------------------------------------------------------
+
+StyleListImpl::~StyleListImpl()
+{
+    StyleBaseImpl *n;
+
+    if(!m_lstChildren) return;
+
+    for( n = m_lstChildren->first(); n != 0; n = m_lstChildren->next() )
+    {
+        n->setParent(0);
+        if( !n->refCount() ) delete n;
+    }
+    delete m_lstChildren;
+}
+
+// --------------------------------------------------------------------------------
+
+void CSSSelector::print(void)
+{
+    kdDebug( 6080 ) << "[Selector: tag = " <<       TQString::number(tag,16) << ", attr = \"" << attr << "\", match = \"" << match
+		    << "\" value = \"" << value.string().latin1() << "\" relation = " << (int)relation
+		    << "]" << endl;
+    if ( tagHistory )
+        tagHistory->print();
+    kdDebug( 6080 ) << "    specificity = " << specificity() << endl;
+}
+
+unsigned int CSSSelector::specificity() const
+{
+    if ( nonCSSHint )
+        return 0;
+
+    int s = ((localNamePart(tag) == anyLocalName) ? 0 : 1);
+    switch(match)
+    {
+    case Id:
+	s += 0x10000;
+	break;
+    case Exact:
+    case Set:
+    case List:
+    case Class:
+    case Hyphen:
+    case PseudoClass:
+    case PseudoElement:
+    case Contain:
+    case Begin:
+    case End:
+        s += 0x100;
+    case None:
+        break;
+    }
+    if(tagHistory)
+        s += tagHistory->specificity();
+    // make sure it doesn't overflow
+    return s & 0xffffff;
+}
+
+void CSSSelector::extractPseudoType() const
+{
+    if (match != PseudoClass && match != PseudoElement)
+        return;
+    _pseudoType = PseudoOther;
+    bool element = false;
+    bool compat = false;
+    if (!value.isEmpty()) {
+        value = value.lower();
+        switch (value[0]) {
+            case '-':
+                if (value == "-tdehtml-replaced")
+                    _pseudoType = PseudoReplaced;
+                else
+                if (value == "-tdehtml-marker")
+                    _pseudoType = PseudoMarker;
+                element = true;
+                break;
+            case 'a':
+                if (value == "active")
+                    _pseudoType = PseudoActive;
+                else if (value == "after") {
+                    _pseudoType = PseudoAfter;
+                    element = compat = true;
+                }
+                break;
+            case 'b':
+                if (value == "before") {
+                    _pseudoType = PseudoBefore;
+                    element = compat = true;
+                }
+                break;
+            case 'c':
+                if (value == "checked")
+                    _pseudoType = PseudoChecked;
+                else if (value == "contains(")
+                    _pseudoType = PseudoContains;
+                break;
+            case 'd':
+                if (value == "disabled")
+                    _pseudoType = PseudoDisabled;
+                break;
+            case 'e':
+                if (value == "empty")
+                    _pseudoType = PseudoEmpty;
+                else if (value == "enabled")
+                    _pseudoType = PseudoEnabled;
+                break;
+            case 'f':
+                if (value == "first-child")
+                    _pseudoType = PseudoFirstChild;
+                else if (value == "first-letter") {
+                    _pseudoType = PseudoFirstLetter;
+                    element = compat = true;
+                }
+                else if (value == "first-line") {
+                    _pseudoType = PseudoFirstLine;
+                    element = compat = true;
+                }
+                else if (value == "first-of-type")
+                    _pseudoType = PseudoFirstOfType;
+                else if (value == "focus")
+                    _pseudoType = PseudoFocus;
+                break;
+            case 'h':
+                if (value == "hover")
+                    _pseudoType = PseudoHover;
+                break;
+            case 'i':
+                if (value == "indeterminate")
+                    _pseudoType = PseudoIndeterminate;
+                break;
+            case 'l':
+                if (value == "link")
+                    _pseudoType = PseudoLink;
+                else if (value == "lang(")
+                    _pseudoType = PseudoLang;
+                else if (value == "last-child")
+                    _pseudoType = PseudoLastChild;
+                else if (value == "last-of-type")
+                    _pseudoType = PseudoLastOfType;
+                break;
+            case 'n':
+                if (value == "not(")
+                    _pseudoType = PseudoNot;
+                else if (value == "nth-child(")
+                    _pseudoType = PseudoNthChild;
+                else if (value == "nth-last-child(")
+                    _pseudoType = PseudoNthLastChild;
+                else if (value == "nth-of-type(")
+                    _pseudoType = PseudoNthOfType;
+                else if (value == "nth-last-of-type(")
+                    _pseudoType = PseudoNthLastOfType;
+                break;
+            case 'o':
+                if (value == "only-child")
+                    _pseudoType = PseudoOnlyChild;
+                else if (value == "only-of-type")
+                    _pseudoType = PseudoOnlyOfType;
+                break;
+            case 'r':
+                if (value == "root")
+                    _pseudoType = PseudoRoot;
+                break;
+            case 's':
+                if (value == "selection") {
+                    _pseudoType = PseudoSelection;
+                    element = true;
+                }
+                break;
+            case 't':
+                if (value == "target")
+                    _pseudoType = PseudoTarget;
+                break;
+            case 'v':
+                if (value == "visited")
+                    _pseudoType = PseudoVisited;
+                break;
+        }
+    }
+    if (match == PseudoClass && element)
+        if (!compat) _pseudoType = PseudoOther;
+        else match = PseudoElement;
+    else
+    if (match == PseudoElement && !element)
+        _pseudoType = PseudoOther;
+}
+
+
+bool CSSSelector::operator == ( const CSSSelector &other ) const
+{
+    const CSSSelector *sel1 = this;
+    const CSSSelector *sel2 = &other;
+
+    while ( sel1 && sel2 ) {
+        //assert(sel1->_pseudoType != PseudoNotParsed);
+        //assert(sel2->_pseudoType != PseudoNotParsed);
+	if ( sel1->tag != sel2->tag || sel1->attr != sel2->attr ||
+	     sel1->relation != sel2->relation || sel1->match != sel2->match ||
+	     sel1->nonCSSHint != sel2->nonCSSHint ||
+	     sel1->value != sel2->value ||
+             sel1->pseudoType() != sel2->pseudoType() ||
+             sel1->string_arg != sel2->string_arg)
+	    return false;
+	sel1 = sel1->tagHistory;
+	sel2 = sel2->tagHistory;
+    }
+    if ( sel1 || sel2 )
+	return false;
+    return true;
+}
+
+DOMString CSSSelector::selectorText() const
+{
+    // FIXME: Support namespaces when dumping the selector text.  This requires preserving
+    // the original namespace prefix used. Ugh. -dwh
+    DOMString str;
+    const CSSSelector* cs = this;
+    TQ_UINT16 tag = localNamePart(cs->tag);
+    if (tag == anyLocalName && cs->match == CSSSelector::None)
+        str = "*";
+    else if (tag != anyLocalName)
+        str = getTagName( cs->tag );
+
+    const CSSSelector* op = 0;
+    while (true) {
+        if ( cs->attr == ATTR_ID && cs->match == CSSSelector::Id )
+        {
+            str += "#";
+            str += cs->value;
+        }
+        else if ( cs->match == CSSSelector::Class )
+        {
+            str += ".";
+            str += cs->value;
+        }
+        else if ( cs->match == CSSSelector::PseudoClass )
+        {
+            str += ":";
+            str += cs->value;
+            if (!cs->string_arg.isEmpty()) { // e.g :nth-child(...)
+                str += cs->string_arg;
+                str += ")";
+            } else if (cs->simpleSelector && !op) { // :not(...)
+                op = cs;
+                cs = cs->simpleSelector;
+                continue;
+            }
+        }
+        else if ( cs->match == CSSSelector::PseudoElement )
+        {
+            str += "::";
+            str += cs->value;
+        }
+        // optional attribute
+        else if ( cs->attr ) {
+            DOMString attrName = getAttrName( cs->attr );
+            str += "[";
+            str += attrName;
+            switch (cs->match) {
+            case CSSSelector::Exact:
+                str += "=";
+                break;
+            case CSSSelector::Set:
+                break;
+            case CSSSelector::List:
+                str += "~=";
+                break;
+            case CSSSelector::Hyphen:
+                str += "|=";
+                break;
+            case CSSSelector::Begin:
+                str += "^=";
+                break;
+            case CSSSelector::End:
+                str += "$=";
+                break;
+            case CSSSelector::Contain:
+                str += "*=";
+                break;
+            default:
+                kdWarning(6080) << "Unhandled case in CSSStyleRuleImpl::selectorText : match=" << cs->match << endl;
+            }
+            if (cs->match != CSSSelector::Set) {
+                str += "\"";
+                str += cs->value;
+                str += "\"";
+            }
+            str += "]";
+        }
+        if (op && !cs->tagHistory) {
+            cs=op;
+            op=0;
+            str += ")";
+        }
+
+        if ((cs->relation != CSSSelector::SubSelector && !op) || !cs->tagHistory)
+            break;
+        cs = cs->tagHistory;
+    }
+
+    if ( cs->tagHistory ) {
+        DOMString tagHistoryText = cs->tagHistory->selectorText();
+        if ( cs->relation == DirectAdjacent )
+            str = tagHistoryText + " + " + str;
+        else if ( cs->relation == IndirectAdjacent )
+            str = tagHistoryText + " ~ " + str;
+        else if ( cs->relation == Child )
+            str = tagHistoryText + " > " + str;
+        else // Descendant
+            str = tagHistoryText + " " + str;
+    }
+    return str;
+}
+
+// ----------------------------------------------------------------------------
diff --git a/tdehtml/css/css_base.h b/tdehtml/css/css_base.h
new file mode 100644
index 000000000..d2ab4f63f
--- /dev/null
+++ b/tdehtml/css/css_base.h
@@ -0,0 +1,271 @@
+/*
+ * This file is part of the CSS implementation for KDE.
+ *
+ * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org)
+ *               1999 Waldo Bastian (bastian@kde.org)
+ *               2002 Apple Computer, Inc.
+ *               2004 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.
+ *
+ */
+#ifndef _CSS_BASE_H
+#define _CSS_BASE_H
+
+#include "dom/dom_string.h"
+#include "dom/dom_misc.h"
+#include "xml/dom_nodeimpl.h"
+#include "misc/shared.h"
+#include <kdemacros.h>
+#include <tqdatetime.h>
+#include <tqptrlist.h>
+
+namespace DOM {
+
+    class StyleSheetImpl;
+    class MediaList;
+
+    class CSSSelector;
+    class CSSProperty;
+    class CSSValueImpl;
+    class CSSPrimitiveValueImpl;
+    class CSSStyleDeclarationImpl;
+    class CSSRuleImpl;
+    class CSSStyleRuleImpl;
+
+    class DocumentImpl;
+
+    struct CSSNamespace {
+        DOMString m_prefix;
+        DOMString m_uri;
+        CSSNamespace* m_parent;
+
+        CSSNamespace(const DOMString& p, const DOMString& u, CSSNamespace* parent)
+            :m_prefix(p), m_uri(u), m_parent(parent) {}
+        ~CSSNamespace() { delete m_parent; }
+
+        const DOMString& uri() { return m_uri; }
+        const DOMString& prefix() { return m_prefix; }
+
+        CSSNamespace* namespaceForPrefix(const DOMString& prefix) {
+            if (prefix == m_prefix)
+                return this;
+            if (m_parent)
+                return m_parent->namespaceForPrefix(prefix);
+            return 0;
+        }
+    };
+
+// this class represents a selector for a StyleRule
+    class CSSSelector
+    {
+    public:
+	CSSSelector()
+	    : tagHistory(0), simpleSelector(0), attr(0), tag(anyQName), relation( Descendant ),
+	      match( None ), nonCSSHint( false ), pseudoId( 0 ), _pseudoType(PseudoNotParsed)
+        {}
+
+	~CSSSelector() {
+	    delete tagHistory;
+            delete simpleSelector;
+	}
+
+	/**
+	 * Print debug output for this selector
+	 */
+	void print();
+
+	/**
+	 * Re-create selector text from selector's data
+	 */
+	DOMString selectorText() const;
+
+	// checks if the 2 selectors (including sub selectors) agree.
+	bool operator == ( const CSSSelector &other ) const;
+
+	// tag == -1 means apply to all elements (Selector = *)
+
+	unsigned int specificity() const;
+
+	/* how the attribute value has to match.... Default is Exact */
+	enum Match
+	{
+	    None = 0,
+	    Id,
+	    Exact,
+	    Set,
+	    Class,
+	    List,
+	    Hyphen,
+	    PseudoClass,
+	    PseudoElement,
+	    Contain,   // css3: E[foo*="bar"]
+	    Begin,     // css3: E[foo^="bar"]
+	    End        // css3: E[foo$="bar"]
+	};
+
+	enum Relation
+	{
+	    Descendant = 0,
+	    Child,
+	    DirectAdjacent,
+            IndirectAdjacent,
+            SubSelector
+	};
+
+	enum PseudoType
+	{
+	    PseudoNotParsed = 0,
+	    PseudoOther,
+	    PseudoEmpty,
+	    PseudoFirstChild,
+            PseudoLastChild,
+            PseudoNthChild,
+            PseudoNthLastChild,
+            PseudoOnlyChild,
+            PseudoFirstOfType,
+            PseudoLastOfType,
+            PseudoNthOfType,
+            PseudoNthLastOfType,
+            PseudoOnlyOfType,
+	    PseudoLink,
+	    PseudoVisited,
+	    PseudoHover,
+	    PseudoFocus,
+	    PseudoActive,
+            PseudoTarget,
+            PseudoLang,
+            PseudoNot,
+            PseudoContains,
+            PseudoRoot,
+            PseudoEnabled,
+            PseudoDisabled,
+            PseudoChecked,
+            PseudoIndeterminate,
+// pseudo-elements:
+    // inherited:
+            PseudoFirstLine,
+            PseudoFirstLetter,
+            PseudoSelection,
+    // generated:
+            PseudoBefore,
+            PseudoAfter,
+            PseudoMarker,
+            PseudoReplaced
+	};
+
+	PseudoType pseudoType() const {
+            if (_pseudoType == PseudoNotParsed)
+                extractPseudoType();
+            return _pseudoType;
+        }
+
+        mutable DOM::DOMString value;
+	CSSSelector *tagHistory;
+        CSSSelector* simpleSelector; // Used by :not
+        DOM::DOMString string_arg; // Used by :contains, :lang and :nth-*
+        DOM::NodeImpl::Id attr;
+        DOM::NodeImpl::Id tag;
+
+	Relation relation     : 3;
+	mutable Match 	 match         : 4;
+	bool	nonCSSHint : 1;
+	unsigned int pseudoId : 4;
+	mutable PseudoType _pseudoType : 6;
+
+    private:
+	void extractPseudoType() const;
+    };
+
+    // a style class which has a parent (almost all have)
+    class StyleBaseImpl : public tdehtml::TreeShared<StyleBaseImpl>
+    {
+    public:
+	StyleBaseImpl()  { m_parent = 0; hasInlinedDecl = false; strictParsing = true; multiLength = false; }
+	StyleBaseImpl(StyleBaseImpl *p) {
+	    m_parent = p; hasInlinedDecl = false;
+	    strictParsing = (m_parent ? m_parent->useStrictParsing() : true);
+	    multiLength = false;
+	}
+
+	virtual ~StyleBaseImpl() {}
+
+	// returns the url of the style sheet this object belongs to
+        // not const
+	KURL baseURL();
+
+	virtual bool isStyleSheet() const { return false; }
+	virtual bool isCSSStyleSheet() const { return false; }
+	virtual bool isStyleSheetList() const { return false; }
+	virtual bool isMediaList() const { return false; }
+	virtual bool isRuleList() const { return false; }
+	virtual bool isRule() const { return false; }
+	virtual bool isStyleRule() const { return false; }
+	virtual bool isCharetRule() const { return false; }
+	virtual bool isImportRule() const { return false; }
+	virtual bool isMediaRule() const { return false; }
+	virtual bool isFontFaceRule() const { return false; }
+	virtual bool isPageRule() const { return false; }
+	virtual bool isUnknownRule() const { return false; }
+	virtual bool isStyleDeclaration() const { return false; }
+	virtual bool isValue() const { return false; }
+	virtual bool isPrimitiveValue() const { return false; }
+	virtual bool isValueList() const { return false; }
+	virtual bool isValueCustom() const { return false; }
+
+	void setParent(StyleBaseImpl *parent) { m_parent = parent; }
+
+	static void setParsedValue(int propId, const CSSValueImpl *parsedValue,
+				   bool important, bool nonCSSHint, TQPtrList<CSSProperty> *propList);
+
+	virtual bool parseString(const DOMString &/*cssString*/, bool = false) { return false; }
+
+	virtual void checkLoaded() const;
+
+	void setStrictParsing( bool b ) { strictParsing = b; }
+	bool useStrictParsing() const { return strictParsing; }
+
+        // not const
+	StyleSheetImpl* stylesheet();
+
+    protected:
+	bool hasInlinedDecl : 1;
+	bool strictParsing : 1;
+	bool multiLength : 1;
+    };
+
+    // a style class which has a list of children (StyleSheets for example)
+    class StyleListImpl : public StyleBaseImpl
+    {
+    public:
+	StyleListImpl() : StyleBaseImpl() { m_lstChildren = 0; }
+	StyleListImpl(StyleBaseImpl *parent) : StyleBaseImpl(parent) { m_lstChildren = 0; }
+	virtual ~StyleListImpl();
+
+	unsigned long length() const { return m_lstChildren->count(); }
+	StyleBaseImpl *item(unsigned long num) const { return m_lstChildren->at(num); }
+
+	void append(StyleBaseImpl *item) { m_lstChildren->append(item); }
+
+    protected:
+	TQPtrList<StyleBaseImpl> *m_lstChildren;
+    };
+
+    KDE_NO_EXPORT int getPropertyID(const char *tagStr, int len);
+
+}
+
+#endif
diff --git a/tdehtml/css/css_extensionsimpl.cpp b/tdehtml/css/css_extensionsimpl.cpp
new file mode 100644
index 000000000..e0e17e207
--- /dev/null
+++ b/tdehtml/css/css_extensionsimpl.cpp
@@ -0,0 +1,366 @@
+/**
+ * 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.
+ *
+ */
+#include "DOMException.h"
+#include "DOMString.h"
+
+#include "CSS2AzimuthImpl.h"
+using namespace DOM;
+
+CSS2AzimuthImpl::CSS2AzimuthImpl(DocumentImpl *doc) : CSSValueImpl(doc)
+{
+}
+
+CSS2AzimuthImpl::~CSS2AzimuthImpl()
+{
+}
+
+unsigned short CSS2AzimuthImpl::azimuthType() const
+{
+}
+
+DOMString CSS2AzimuthImpl::identifier() const
+{
+}
+
+bool CSS2AzimuthImpl::behind() const
+{
+}
+
+void CSS2AzimuthImpl::setAngleValue( const unsigned short &unitType, const float &floatValue )
+{
+}
+
+float CSS2AzimuthImpl::getAngleValue( const unsigned short &unitType )
+{
+}
+
+void CSS2AzimuthImpl::setIdentifier( const DOMString &identifier, const bool &behind )
+{
+}
+
+
+
+
+
+#include "CSS2BackgroundPositionImpl.h"
+CSS2BackgroundPositionImpl::CSS2BackgroundPositionImpl(DocumentImpl *doc) : CSSValueImpl(doc)
+{
+}
+
+CSS2BackgroundPositionImpl::~CSS2BackgroundPositionImpl()
+{
+}
+
+unsigned short CSS2BackgroundPositionImpl::horizontalType() const
+{
+}
+
+unsigned short CSS2BackgroundPositionImpl::verticalType() const
+{
+}
+
+DOMString CSS2BackgroundPositionImpl::horizontalIdentifier() const
+{
+}
+
+DOMString CSS2BackgroundPositionImpl::verticalIdentifier() const
+{
+}
+
+float CSS2BackgroundPositionImpl::getHorizontalPosition( const float &horizontalType )
+{
+}
+
+float CSS2BackgroundPositionImpl::getVerticalPosition( const float &verticalType )
+{
+}
+
+void CSS2BackgroundPositionImpl::setHorizontalPosition( const unsigned short &horizontalType, const float &value )
+{
+}
+
+void CSS2BackgroundPositionImpl::setVerticalPosition( const unsigned short &verticalType, const float &value )
+{
+}
+
+void CSS2BackgroundPositionImpl::setPositionIdentifier( const DOMString &horizontalIdentifier, const DOMString &verticalIdentifier )
+{
+}
+
+
+
+
+
+#include "CSS2BorderSpacingImpl.h"
+CSS2BorderSpacingImpl::CSS2BorderSpacingImpl(DocumentImpl *doc) : CSSValueImpl(doc)
+{
+}
+
+CSS2BorderSpacingImpl::~CSS2BorderSpacingImpl()
+{
+}
+
+unsigned short CSS2BorderSpacingImpl::horizontalType() const
+{
+}
+
+unsigned short CSS2BorderSpacingImpl::verticalType() const
+{
+}
+
+float CSS2BorderSpacingImpl::getHorizontalSpacing( const float &horizontalType )
+{
+}
+
+float CSS2BorderSpacingImpl::getVerticalSpacing( const float &verticalType )
+{
+}
+
+void CSS2BorderSpacingImpl::setHorizontalSpacing( const unsigned short &horizontalType, const float &value )
+{
+}
+
+void CSS2BorderSpacingImpl::setVerticalSpacing( const unsigned short &verticalType, const float &value )
+{
+}
+
+void CSS2BorderSpacingImpl::setInherit()
+{
+}
+
+
+
+
+
+#include "CSS2CounterIncrementImpl.h"
+CSS2CounterIncrementImpl::CSS2CounterIncrementImpl(DocumentImpl *doc)
+{
+}
+
+CSS2CounterIncrementImpl::~CSS2CounterIncrementImpl()
+{
+}
+
+short CSS2CounterIncrementImpl::increment() const
+{
+}
+
+void CSS2CounterIncrementImpl::setIncrement( const short & )
+{
+}
+
+
+
+
+
+#include "CSS2CounterResetImpl.h"
+CSS2CounterResetImpl::CSS2CounterResetImpl(DocumentImpl *doc)
+{
+}
+
+CSS2CounterResetImpl::~CSS2CounterResetImpl()
+{
+}
+
+short CSS2CounterResetImpl::reset() const
+{
+}
+
+void CSS2CounterResetImpl::setReset( const short & )
+{
+}
+
+
+
+
+#include "CSSValueList.h"
+#include "CSS2CursorImpl.h"
+CSS2CursorImpl::CSS2CursorImpl(DocumentImpl *doc) : CSSValueImpl(doc)
+{
+}
+
+CSS2CursorImpl::~CSS2CursorImpl()
+{
+}
+
+unsigned short CSS2CursorImpl::cursorType() const
+{
+}
+
+void CSS2CursorImpl::setCursorType( const unsigned short & )
+{
+}
+
+CSSValueList CSS2CursorImpl::uris() const
+{
+}
+
+#include "CSS2FontFaceSrcImpl.h"
+CSS2FontFaceSrcImpl::CSS2FontFaceSrcImpl(DocumentImpl *doc)
+{
+}
+
+CSS2FontFaceSrcImpl::~CSS2FontFaceSrcImpl()
+{
+}
+
+CSSValueList CSS2FontFaceSrcImpl::format() const
+{
+}
+
+
+
+
+#include "CSS2FontFaceWidthsImpl.h"
+CSS2FontFaceWidthsImpl::CSS2FontFaceWidthsImpl(DocumentImpl *doc)
+{
+}
+
+CSS2FontFaceWidthsImpl::~CSS2FontFaceWidthsImpl()
+{
+}
+
+CSSValueList CSS2FontFaceWidthsImpl::numbers() const
+{
+}
+
+
+
+
+#include "CSS2PageSizeImpl.h"
+CSS2PageSizeImpl::CSS2PageSizeImpl(DocumentImpl *doc) : CSSValueImpl(doc)
+{
+}
+
+CSS2PageSizeImpl::~CSS2PageSizeImpl()
+{
+}
+
+unsigned short CSS2PageSizeImpl::widthType() const
+{
+}
+
+unsigned short CSS2PageSizeImpl::heightType() const
+{
+}
+
+DOMString CSS2PageSizeImpl::identifier() const
+{
+}
+
+float CSS2PageSizeImpl::getWidth( const float &widthType )
+{
+}
+
+float CSS2PageSizeImpl::getHeightSize( const float &heightType )
+{
+}
+
+void CSS2PageSizeImpl::setWidthSize( const unsigned short &widthType, const float &value )
+{
+}
+
+void CSS2PageSizeImpl::setHeightSize( const unsigned short &heightType, const float &value )
+{
+}
+
+void CSS2PageSizeImpl::setIdentifier( const DOMString &identifier )
+{
+}
+
+
+
+
+#include "CSS2PlayDuringImpl.h"
+CSS2PlayDuringImpl::CSS2PlayDuringImpl(DocumentImpl *doc) : CSSValueImpl(doc)
+{
+}
+
+CSS2PlayDuringImpl::~CSS2PlayDuringImpl()
+{
+}
+
+unsigned short CSS2PlayDuringImpl::playDuringType() const
+{
+}
+
+bool CSS2PlayDuringImpl::mix() const
+{
+}
+
+void CSS2PlayDuringImpl::setMix( const bool & )
+{
+}
+
+bool CSS2PlayDuringImpl::repeat() const
+{
+}
+
+void CSS2PlayDuringImpl::setRepeat( const bool & )
+{
+}
+
+
+
+
+
+#include "CSS2PropertiesImpl.h"
+CSS2PropertiesImpl::CSS2PropertiesImpl(DocumentImpl *doc)
+{
+}
+
+CSS2PropertiesImpl::~CSS2PropertiesImpl()
+{
+}
+
+
+
+
+#include "CSSValue.h"
+
+#include "CSS2TextShadowImpl.h"
+CSS2TextShadowImpl::CSS2TextShadowImpl(DocumentImpl *doc)
+{
+}
+
+CSS2TextShadowImpl::~CSS2TextShadowImpl()
+{
+}
+
+CSSValue CSS2TextShadowImpl::color() const
+{
+}
+
+CSSValue CSS2TextShadowImpl::horizontal() const
+{
+}
+
+CSSValue CSS2TextShadowImpl::vertical() const
+{
+}
+
+CSSValue CSS2TextShadowImpl::blur() const
+{
+}
+
+
+
diff --git a/tdehtml/css/css_extensionsimpl.h b/tdehtml/css/css_extensionsimpl.h
new file mode 100644
index 000000000..dba74e217
--- /dev/null
+++ b/tdehtml/css/css_extensionsimpl.h
@@ -0,0 +1,205 @@
+/*
+ * 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.
+ *
+ */
+#ifndef _CSS_css_extensionsimpl_h_
+#define _CSS_css_extensionsimpl_h_
+
+#include "css_valueimpl.h"
+#include "dom_string.h"
+
+namespace DOM {
+
+class CSS2AzimuthImpl : public CSSValueImpl
+{
+public:
+    CSS2AzimuthImpl(DocumentImpl *doc);
+
+    ~CSS2AzimuthImpl();
+
+    unsigned short azimuthType() const;
+    DOM::DOMString identifier() const;
+    bool behind() const;
+    void setAngleValue ( const unsigned short &unitType, const float &floatValue );
+    float getAngleValue ( const unsigned short &unitType );
+    void setIdentifier ( const DOM::DOMString &identifier, const bool &behind );
+};
+
+
+class DOM::DOMString;
+
+class CSS2BackgroundPositionImpl : public CSSValueImpl
+{
+public:
+    CSS2BackgroundPositionImpl(DocumentImpl *doc);
+
+    ~CSS2BackgroundPositionImpl();
+
+    unsigned short horizontalType() const;
+    unsigned short verticalType() const;
+    DOM::DOMString horizontalIdentifier() const;
+    DOM::DOMString verticalIdentifier() const;
+    float getHorizontalPosition ( const float &horizontalType );
+    float getVerticalPosition ( const float &verticalType );
+    void setHorizontalPosition ( const unsigned short &horizontalType, const float &value );
+    void setVerticalPosition ( const unsigned short &verticalType, const float &value );
+    void setPositionIdentifier ( const DOM::DOMString &horizontalIdentifier, const DOM::DOMString &verticalIdentifier );
+};
+
+
+
+class CSS2BorderSpacingImpl : public CSSValueImpl
+{
+public:
+    CSS2BorderSpacingImpl(DocumentImpl *doc);
+
+    ~CSS2BorderSpacingImpl();
+
+    unsigned short horizontalType() const;
+    unsigned short verticalType() const;
+    float getHorizontalSpacing ( const float &horizontalType );
+    float getVerticalSpacing ( const float &verticalType );
+    void setHorizontalSpacing ( const unsigned short &horizontalType, const float &value );
+    void setVerticalSpacing ( const unsigned short &verticalType, const float &value );
+    void setInherit();
+};
+
+
+class CSS2CounterIncrementImpl
+{
+public:
+    CSS2CounterIncrementImpl(DocumentImpl *doc);
+
+    ~CSS2CounterIncrementImpl();
+
+    short increment() const;
+    void setIncrement( const short & );
+};
+
+
+class CSS2CounterResetImpl
+{
+public:
+    CSS2CounterResetImpl(DocumentImpl *doc);
+
+    ~CSS2CounterResetImpl();
+
+    short reset() const;
+    void setReset( const short & );
+};
+
+
+class CSS2CursorImpl : public CSSValueImpl
+{
+public:
+    CSS2CursorImpl(DocumentImpl *doc);
+
+    ~CSS2CursorImpl();
+
+    unsigned short cursorType() const;
+    void setCursorType( const unsigned short & );
+
+    CSSValueList uris() const;
+};
+
+
+class CSS2FontFaceSrcImpl
+{
+public:
+    CSS2FontFaceSrcImpl(DocumentImpl *doc);
+
+    ~CSS2FontFaceSrcImpl();
+
+    CSSValueList format() const;
+};
+
+
+class CSS2FontFaceWidthsImpl
+{
+public:
+    CSS2FontFaceWidthsImpl(DocumentImpl *doc);
+
+    ~CSS2FontFaceWidthsImpl();
+
+    CSSValueList numbers() const;
+};
+
+
+class CSS2PageSizeImpl : public CSSValueImpl
+{
+public:
+    CSS2PageSizeImpl(DocumentImpl *doc);
+
+    ~CSS2PageSizeImpl();
+
+    unsigned short widthType() const;
+    unsigned short heightType() const;
+    DOM::DOMString identifier() const;
+    float getWidth ( const float &widthType );
+    float getHeightSize ( const float &heightType );
+    void setWidthSize ( const unsigned short &widthType, const float &value );
+    void setHeightSize ( const unsigned short &heightType, const float &value );
+    void setIdentifier ( const DOM::DOMString &identifier );
+};
+
+
+class CSS2PlayDuringImpl : public CSSValueImpl
+{
+public:
+    CSS2PlayDuringImpl(DocumentImpl *doc);
+
+    ~CSS2PlayDuringImpl();
+
+    unsigned short playDuringType() const;
+    bool mix() const;
+
+    void setMix( const bool & );
+    bool repeat() const;
+
+    void setRepeat( const bool & );
+};
+
+
+class CSS2PropertiesImpl
+{
+public:
+    CSS2PropertiesImpl(DocumentImpl *doc);
+
+    ~CSS2PropertiesImpl();
+};
+
+
+class CSS2TextShadowImpl
+{
+public:
+    CSS2TextShadowImpl(DocumentImpl *doc);
+
+    ~CSS2TextShadowImpl();
+
+    CSSValue color() const;
+    CSSValue horizontal() const;
+    CSSValue vertical() const;
+    CSSValue blur() const;
+};
+
+
+}; // namespace
+
+#endif
diff --git a/tdehtml/css/css_renderstyledeclarationimpl.cpp b/tdehtml/css/css_renderstyledeclarationimpl.cpp
new file mode 100644
index 000000000..95c1c95d9
--- /dev/null
+++ b/tdehtml/css/css_renderstyledeclarationimpl.cpp
@@ -0,0 +1,1147 @@
+/**
+ * css_renderstyledeclarationimpl.cpp
+ *
+ * Copyright (C)  2004  Zack Rusin <zack@kde.org>
+ * Copyright (C)  2004,2005 Apple Computer, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301  USA
+ */
+#include "css_renderstyledeclarationimpl.h"
+
+#include "rendering/render_style.h"
+#include "rendering/render_object.h"
+
+#include "cssproperties.h"
+#include "cssvalues.h"
+
+using namespace DOM;
+using namespace tdehtml;
+
+// List of all properties we know how to compute, omitting shorthands.
+static const int computedProperties[] = {
+    CSS_PROP_BACKGROUND_COLOR,
+    CSS_PROP_BACKGROUND_IMAGE,
+    CSS_PROP_BACKGROUND_REPEAT,
+    CSS_PROP_BACKGROUND_ATTACHMENT,
+    CSS_PROP_BACKGROUND_POSITION,
+    CSS_PROP_BACKGROUND_POSITION_X,
+    CSS_PROP_BACKGROUND_POSITION_Y,
+    CSS_PROP_BORDER_COLLAPSE,
+    CSS_PROP_BORDER_SPACING,
+    CSS_PROP__KHTML_BORDER_HORIZONTAL_SPACING,
+    CSS_PROP__KHTML_BORDER_VERTICAL_SPACING,
+    CSS_PROP_BORDER_TOP_COLOR,
+    CSS_PROP_BORDER_RIGHT_COLOR,
+    CSS_PROP_BORDER_BOTTOM_COLOR,
+    CSS_PROP_BORDER_LEFT_COLOR,
+    CSS_PROP_BORDER_TOP_STYLE,
+    CSS_PROP_BORDER_RIGHT_STYLE,
+    CSS_PROP_BORDER_BOTTOM_STYLE,
+    CSS_PROP_BORDER_LEFT_STYLE,
+    CSS_PROP_BORDER_TOP_WIDTH,
+    CSS_PROP_BORDER_RIGHT_WIDTH,
+    CSS_PROP_BORDER_BOTTOM_WIDTH,
+    CSS_PROP_BORDER_LEFT_WIDTH,
+    CSS_PROP_BOTTOM,
+    CSS_PROP_CAPTION_SIDE,
+    CSS_PROP_CLEAR,
+    CSS_PROP_COLOR,
+    CSS_PROP_CURSOR,
+    CSS_PROP_DIRECTION,
+    CSS_PROP_DISPLAY,
+    CSS_PROP_EMPTY_CELLS,
+    CSS_PROP_FLOAT,
+    CSS_PROP_FONT_FAMILY,
+    CSS_PROP_FONT_SIZE,
+    CSS_PROP_FONT_STYLE,
+    CSS_PROP_FONT_VARIANT,
+    CSS_PROP_FONT_WEIGHT,
+    CSS_PROP_HEIGHT,
+    CSS_PROP_LEFT,
+    CSS_PROP_LETTER_SPACING,
+    CSS_PROP_LINE_HEIGHT,
+    CSS_PROP_LIST_STYLE_IMAGE,
+    CSS_PROP_LIST_STYLE_POSITION,
+    CSS_PROP_LIST_STYLE_TYPE,
+    CSS_PROP_MARGIN_TOP,
+    CSS_PROP_MARGIN_RIGHT,
+    CSS_PROP_MARGIN_BOTTOM,
+    CSS_PROP_MARGIN_LEFT,
+    CSS_PROP__KHTML_MARQUEE_DIRECTION,
+    CSS_PROP__KHTML_MARQUEE_INCREMENT,
+    CSS_PROP__KHTML_MARQUEE_REPETITION,
+    CSS_PROP__KHTML_MARQUEE_STYLE,
+    CSS_PROP_MAX_HEIGHT,
+    CSS_PROP_MAX_WIDTH,
+    CSS_PROP_MIN_HEIGHT,
+    CSS_PROP_MIN_WIDTH,
+    CSS_PROP_OPACITY,
+    CSS_PROP_ORPHANS,
+    CSS_PROP_OUTLINE_STYLE,
+    CSS_PROP_OVERFLOW,
+    CSS_PROP_OVERFLOW_X,
+    CSS_PROP_OVERFLOW_Y,
+    CSS_PROP_PADDING_TOP,
+    CSS_PROP_PADDING_RIGHT,
+    CSS_PROP_PADDING_BOTTOM,
+    CSS_PROP_PADDING_LEFT,
+    CSS_PROP_PAGE_BREAK_AFTER,
+    CSS_PROP_PAGE_BREAK_BEFORE,
+    CSS_PROP_PAGE_BREAK_INSIDE,
+    CSS_PROP_POSITION,
+    CSS_PROP_RIGHT,
+    CSS_PROP_TABLE_LAYOUT,
+    CSS_PROP_TEXT_ALIGN,
+    CSS_PROP_TEXT_DECORATION,
+    CSS_PROP_TEXT_INDENT,
+    CSS_PROP_TEXT_SHADOW,
+    CSS_PROP_TEXT_TRANSFORM,
+    CSS_PROP_TOP,
+    CSS_PROP_UNICODE_BIDI,
+    CSS_PROP_VERTICAL_ALIGN,
+    CSS_PROP_VISIBILITY,
+    CSS_PROP_WHITE_SPACE,
+    CSS_PROP_WIDOWS,
+    CSS_PROP_WIDTH,
+    CSS_PROP_WORD_SPACING,
+    CSS_PROP_Z_INDEX,
+};
+
+const unsigned numComputedProperties = sizeof(computedProperties) / sizeof(computedProperties[0]);
+
+
+static CSSValueImpl *valueForLength(const Length &length, int max)
+{
+    if (length.isPercent()) {
+        return new CSSPrimitiveValueImpl(length.value(), CSSPrimitiveValue::CSS_PERCENTAGE);
+    }
+    else {
+        return new CSSPrimitiveValueImpl(length.minWidth(max), CSSPrimitiveValue::CSS_PX);
+    }
+}
+
+static CSSValueImpl *valueForBorderStyle(EBorderStyle style)
+{
+    switch (style) {
+    case tdehtml::BNATIVE:
+        return new CSSPrimitiveValueImpl(CSS_VAL__KHTML_NATIVE);
+    case tdehtml::BNONE:
+        return new CSSPrimitiveValueImpl(CSS_VAL_NONE);
+    case tdehtml::BHIDDEN:
+        return new CSSPrimitiveValueImpl(CSS_VAL_HIDDEN);
+    case tdehtml::INSET:
+        return new CSSPrimitiveValueImpl(CSS_VAL_INSET);
+    case tdehtml::GROOVE:
+        return new CSSPrimitiveValueImpl(CSS_VAL_GROOVE);
+    case tdehtml::RIDGE:
+         return new CSSPrimitiveValueImpl(CSS_VAL_RIDGE);
+    case tdehtml::OUTSET:
+        return new CSSPrimitiveValueImpl(CSS_VAL_OUTSET);
+    case tdehtml::DOTTED:
+        return new CSSPrimitiveValueImpl(CSS_VAL_DOTTED);
+    case tdehtml::DASHED:
+        return new CSSPrimitiveValueImpl(CSS_VAL_DASHED);
+    case tdehtml::SOLID:
+        return new CSSPrimitiveValueImpl(CSS_VAL_SOLID);
+    case tdehtml::DOUBLE:
+        return new CSSPrimitiveValueImpl(CSS_VAL_DOUBLE);
+    }
+    Q_ASSERT( 0 );
+    return 0;
+}
+
+static CSSValueImpl *valueForTextAlign(ETextAlign align)
+{
+    switch (align) {
+    case tdehtml::TAAUTO:
+        return new CSSPrimitiveValueImpl(CSS_VAL_AUTO);
+    case tdehtml::LEFT:
+        return new CSSPrimitiveValueImpl(CSS_VAL_LEFT);
+    case tdehtml::RIGHT:
+        return new CSSPrimitiveValueImpl(CSS_VAL_RIGHT);
+    case tdehtml::CENTER:
+        return new CSSPrimitiveValueImpl(CSS_VAL_CENTER);
+    case tdehtml::JUSTIFY:
+        return new CSSPrimitiveValueImpl(CSS_VAL_JUSTIFY);
+    case tdehtml::KHTML_LEFT:
+        return new CSSPrimitiveValueImpl(CSS_VAL__KHTML_LEFT);
+    case tdehtml::KHTML_RIGHT:
+        return new CSSPrimitiveValueImpl(CSS_VAL__KHTML_RIGHT);
+    case tdehtml::KHTML_CENTER:
+        return new CSSPrimitiveValueImpl(CSS_VAL__KHTML_CENTER);
+    }
+    Q_ASSERT( 0 );
+    return 0;
+}
+
+DOMString tdehtml::stringForListStyleType(EListStyleType type)
+{
+    switch (type) {
+        case tdehtml::LDISC:
+            return "disc";
+        case tdehtml::LCIRCLE:
+            return "circle";
+        case tdehtml::LSQUARE:
+            return "square";
+        case tdehtml::LBOX:
+            return "box";
+        case tdehtml::LDIAMOND:
+            return "-tdehtml-diamond";
+        case tdehtml::LDECIMAL:
+            return "decimal";
+        case tdehtml::DECIMAL_LEADING_ZERO:
+            return "decimal-leading-zero";
+        case tdehtml::ARABIC_INDIC:
+            return "-tdehtml-arabic-indic";
+        case tdehtml::LAO:
+            return "-tdehtml-lao";
+        case tdehtml::PERSIAN:
+            return "-tdehtml-persian";
+        case tdehtml::URDU:
+            return "-tdehtml-urdu";
+        case tdehtml::THAI:
+            return "-tdehtml-thai";
+        case tdehtml::TIBETAN:
+            return "-tdehtml-tibetan";
+        case tdehtml::LOWER_ROMAN:
+            return "lower-roman";
+        case tdehtml::UPPER_ROMAN:
+            return "upper-roman";
+        case tdehtml::HEBREW:
+            return "hebrew";
+        case tdehtml::ARMENIAN:
+            return "armenian";
+        case tdehtml::GEORGIAN:
+            return "georgian";
+        case tdehtml::CJK_IDEOGRAPHIC:
+            return "cjk-ideographic";
+        case tdehtml::JAPANESE_FORMAL:
+            return "-tdehtml-japanese-formal";
+        case tdehtml::JAPANESE_INFORMAL:
+            return "-tdehtml-japanese-informal";
+        case tdehtml::SIMP_CHINESE_FORMAL:
+            return "-tdehtml-simp-chinese-formal";
+        case tdehtml::SIMP_CHINESE_INFORMAL:
+            return "-tdehtml-simp-chinese-informal";
+        case tdehtml::TRAD_CHINESE_FORMAL:
+            return "-tdehtml-trad-chinese-formal";
+        case tdehtml::TRAD_CHINESE_INFORMAL:
+            return "-tdehtml-trad-chinese-informal";
+        case tdehtml::LOWER_GREEK:
+            return "lower-greek";
+        case tdehtml::UPPER_GREEK:
+            return "-tdehtml-upper-greek";
+        case tdehtml::LOWER_ALPHA:
+            return "lower-alpha";
+        case tdehtml::UPPER_ALPHA:
+            return "upper-alpha";
+        case tdehtml::LOWER_LATIN:
+            return "lower-latin";
+        case tdehtml::UPPER_LATIN:
+            return "upper-latin";
+        case tdehtml::HIRAGANA:
+            return "hiragana";
+        case tdehtml::KATAKANA:
+            return "katakana";
+        case tdehtml::HIRAGANA_IROHA:
+            return "hiragana-iroha";
+        case tdehtml::KATAKANA_IROHA:
+            return "katakana_iroha";
+        case tdehtml::LNONE:
+            return "none";
+    }
+    Q_ASSERT( 0 );
+    return "";
+}
+
+static CSSPrimitiveValueImpl* valueForColor(TQColor color)
+{
+    if (color.isValid())
+        return new CSSPrimitiveValueImpl(color.rgb());//### KDE4: use rgba!
+    else
+        return new CSSPrimitiveValueImpl(tdehtml::transparentColor);
+}
+
+static CSSValueImpl* valueForShadow(const ShadowData *shadow)
+{
+    if (!shadow)
+        return new CSSPrimitiveValueImpl(CSS_VAL_NONE);
+    CSSValueListImpl *list = new CSSValueListImpl;
+    for (const ShadowData *s = shadow; s; s = s->next) {
+        CSSPrimitiveValueImpl *x = new CSSPrimitiveValueImpl(s->x, CSSPrimitiveValue::CSS_PX);
+        CSSPrimitiveValueImpl *y = new CSSPrimitiveValueImpl(s->y, CSSPrimitiveValue::CSS_PX);
+        CSSPrimitiveValueImpl *blur = new CSSPrimitiveValueImpl(s->blur, CSSPrimitiveValue::CSS_PX);
+        CSSPrimitiveValueImpl *color = valueForColor(s->color);
+        list->append(new ShadowValueImpl(x, y, blur, color));
+    }
+    return list;
+}
+
+static CSSValueImpl *getPositionOffsetValue(RenderObject *renderer, int propertyID)
+{
+    if (!renderer)
+        return 0;
+
+    RenderStyle *style = renderer->style();
+    if (!style)
+        return 0;
+
+    Length l;
+    switch (propertyID) {
+    case CSS_PROP_LEFT:
+        l = style->left();
+        break;
+    case CSS_PROP_RIGHT:
+        l = style->right();
+        break;
+    case CSS_PROP_TOP:
+        l = style->top();
+        break;
+    case CSS_PROP_BOTTOM:
+        l = style->bottom();
+        break;
+    default:
+        return 0;
+    }
+
+    if (renderer->isPositioned())
+        return valueForLength(l, renderer->contentWidth());
+
+    if (renderer->isRelPositioned())
+        // FIXME: It's not enough to simply return "auto" values for one offset if the other side is defined.
+        // In other words if left is auto and right is not auto, then left's computed value is negative right.
+        // So we should get the opposite length unit and see if it is auto.
+        return valueForLength(l, renderer->contentWidth());
+
+    return new CSSPrimitiveValueImpl(CSS_VAL_AUTO);
+ }
+
+RenderStyleDeclarationImpl::RenderStyleDeclarationImpl( DOM::NodeImpl *node )
+    : CSSStyleDeclarationImpl(0), m_node(node)
+{
+    //kdDebug() << "Render Style Declaration created" << endl;
+}
+
+RenderStyleDeclarationImpl::~RenderStyleDeclarationImpl()
+{
+    //kdDebug() << "Render Style Declaration destroyed" << endl;
+}
+
+DOM::DOMString RenderStyleDeclarationImpl::cssText() const
+{
+    DOMString result;
+
+    for (unsigned i = 0; i < numComputedProperties; i++) {
+        if (i != 0)
+            result += " ";
+        result += getPropertyName(computedProperties[i]);
+        result += ": ";
+        result += getPropertyValue(computedProperties[i]);
+        result += ";";
+    }
+
+    return result;
+}
+
+void RenderStyleDeclarationImpl::setCssText( DOM::DOMString )
+{
+    // ### report that this sucka is read only
+}
+
+CSSValueImpl *RenderStyleDeclarationImpl::getPropertyCSSValue( int propertyID ) const
+{
+    NodeImpl *node = m_node.get();
+    if (!node)
+        return 0;
+
+    // Make sure our layout is up to date before we allow a query on these attributes.
+    DocumentImpl* docimpl = node->getDocument();
+    if (docimpl) {
+        docimpl->updateLayout();
+    }
+
+    RenderObject *renderer = m_node->renderer();
+    if (!renderer)
+        return 0;
+    RenderStyle *style = renderer->style();
+    if (!style)
+        return 0;
+
+    switch(propertyID)
+    {
+    case CSS_PROP_BACKGROUND_COLOR:
+        return valueForColor(style->backgroundColor());
+    case CSS_PROP_BACKGROUND_IMAGE:
+        if (style->backgroundImage())
+            return new CSSPrimitiveValueImpl(style->backgroundImage()->url(),
+                                             CSSPrimitiveValue::CSS_URI);
+        return new CSSPrimitiveValueImpl(CSS_VAL_NONE);
+    case CSS_PROP_BACKGROUND_REPEAT:
+        switch (style->backgroundRepeat()) {
+        case tdehtml::REPEAT:
+            return new CSSPrimitiveValueImpl(CSS_VAL_REPEAT);
+        case tdehtml::REPEAT_X:
+            return new CSSPrimitiveValueImpl(CSS_VAL_REPEAT_X);
+        case tdehtml::REPEAT_Y:
+            return new CSSPrimitiveValueImpl(CSS_VAL_REPEAT_Y);
+        case tdehtml::NO_REPEAT:
+            return new CSSPrimitiveValueImpl(CSS_VAL_NO_REPEAT);
+        default:
+            Q_ASSERT( 0 );
+        }
+    case CSS_PROP_BACKGROUND_ATTACHMENT:
+        if (style->backgroundAttachment())
+            return new CSSPrimitiveValueImpl(CSS_VAL_SCROLL);
+        else
+            return new CSSPrimitiveValueImpl(CSS_VAL_FIXED);
+    case CSS_PROP_BACKGROUND_POSITION:
+    {
+        DOMString string;
+        Length length(style->backgroundXPosition());
+        if (length.isPercent())
+            string = TQString::number(length.value()) + "%";
+        else
+            string = TQString::number(length.minWidth(renderer->contentWidth()));
+        string += " ";
+        length = style->backgroundYPosition();
+        if (length.isPercent())
+            string += TQString::number(length.value()) + "%";
+        else
+            string += TQString::number(length.minWidth(renderer->contentWidth()));
+        return new CSSPrimitiveValueImpl(string, CSSPrimitiveValue::CSS_STRING);
+    }
+    case CSS_PROP_BACKGROUND_POSITION_X:
+        return valueForLength(style->backgroundXPosition(), renderer->contentWidth());
+    case CSS_PROP_BACKGROUND_POSITION_Y:
+        return valueForLength(style->backgroundYPosition(), renderer->contentHeight());
+    case CSS_PROP_BORDER_COLLAPSE:
+        if (style->borderCollapse())
+            return new CSSPrimitiveValueImpl(CSS_VAL_COLLAPSE);
+        else
+            return new CSSPrimitiveValueImpl(CSS_VAL_SEPARATE);
+    case CSS_PROP_BORDER_SPACING:
+    {
+        TQString string(TQString::number(style->borderHorizontalSpacing()) +
+                       "px " +
+                       TQString::number(style->borderVerticalSpacing()) +
+                       "px");
+        return new CSSPrimitiveValueImpl(string, CSSPrimitiveValue::CSS_STRING);
+    }
+    case CSS_PROP__KHTML_BORDER_HORIZONTAL_SPACING:
+        return new CSSPrimitiveValueImpl(style->borderHorizontalSpacing(),
+                                         CSSPrimitiveValue::CSS_PX);
+    case CSS_PROP__KHTML_BORDER_VERTICAL_SPACING:
+        return new CSSPrimitiveValueImpl(style->borderVerticalSpacing(),
+                                         CSSPrimitiveValue::CSS_PX);
+    case CSS_PROP_BORDER_TOP_COLOR:
+        return valueForColor(style->borderTopColor());
+    case CSS_PROP_BORDER_RIGHT_COLOR:
+        return valueForColor(style->borderRightColor());
+    case CSS_PROP_BORDER_BOTTOM_COLOR:
+        return valueForColor(style->borderBottomColor());
+    case CSS_PROP_BORDER_LEFT_COLOR:
+        return valueForColor(style->borderLeftColor());
+    case CSS_PROP_BORDER_TOP_STYLE:
+        return valueForBorderStyle(style->borderTopStyle());
+    case CSS_PROP_BORDER_RIGHT_STYLE:
+        return valueForBorderStyle(style->borderRightStyle());
+    case CSS_PROP_BORDER_BOTTOM_STYLE:
+        return valueForBorderStyle(style->borderBottomStyle());
+    case CSS_PROP_BORDER_LEFT_STYLE:
+        return valueForBorderStyle(style->borderLeftStyle());
+    case CSS_PROP_BORDER_TOP_WIDTH:
+        return new CSSPrimitiveValueImpl( style->borderTopWidth(), CSSPrimitiveValue::CSS_PX );
+    case CSS_PROP_BORDER_RIGHT_WIDTH:
+        return new CSSPrimitiveValueImpl( style->borderRightWidth(), CSSPrimitiveValue::CSS_PX );
+    case CSS_PROP_BORDER_BOTTOM_WIDTH:
+        return new CSSPrimitiveValueImpl( style->borderBottomWidth(), CSSPrimitiveValue::CSS_PX );
+    case CSS_PROP_BORDER_LEFT_WIDTH:
+        return new CSSPrimitiveValueImpl( style->borderLeftWidth(), CSSPrimitiveValue::CSS_PX );
+    case CSS_PROP_BOTTOM:
+        return getPositionOffsetValue(renderer, CSS_PROP_BOTTOM);
+    case CSS_PROP_CAPTION_SIDE:
+        switch (style->captionSide()) {
+        case CAPLEFT:
+            return new CSSPrimitiveValueImpl(CSS_VAL_LEFT);
+        case CAPRIGHT:
+            return new CSSPrimitiveValueImpl(CSS_VAL_RIGHT);
+        case CAPTOP:
+            return new CSSPrimitiveValueImpl(CSS_VAL_TOP);
+        case CAPBOTTOM:
+            return new CSSPrimitiveValueImpl(CSS_VAL_BOTTOM);
+        }
+        Q_ASSERT(0);
+        break;
+    case CSS_PROP_CLEAR:
+        switch (style->clear()) {
+        case CNONE:
+            return new CSSPrimitiveValueImpl(CSS_VAL_NONE);
+        case CLEFT:
+            return new CSSPrimitiveValueImpl(CSS_VAL_LEFT);
+        case CRIGHT:
+            return new CSSPrimitiveValueImpl(CSS_VAL_RIGHT);
+        case CBOTH:
+            return new CSSPrimitiveValueImpl(CSS_VAL_BOTH);
+        }
+        Q_ASSERT(0);
+        break;
+    case CSS_PROP_CLIP:
+        break;
+    case CSS_PROP_COLOR:
+        return valueForColor(style->color());
+    case CSS_PROP_CONTENT:
+        break;
+    case CSS_PROP_COUNTER_INCREMENT:
+        break;
+    case CSS_PROP_COUNTER_RESET:
+        break;
+    case CSS_PROP_CURSOR:
+        switch (style->cursor()) {
+        case CURSOR_AUTO:
+            return new CSSPrimitiveValueImpl(CSS_VAL_AUTO);
+        case CURSOR_CROSS:
+            return new CSSPrimitiveValueImpl(CSS_VAL_CROSSHAIR);
+        case CURSOR_DEFAULT:
+            return new CSSPrimitiveValueImpl(CSS_VAL_DEFAULT);
+        case CURSOR_POINTER:
+            return new CSSPrimitiveValueImpl(CSS_VAL_POINTER);
+        case CURSOR_MOVE:
+            return new CSSPrimitiveValueImpl(CSS_VAL_MOVE);
+        case CURSOR_PROGRESS:
+            return new CSSPrimitiveValueImpl(CSS_VAL_PROGRESS);
+        case CURSOR_E_RESIZE:
+            return new CSSPrimitiveValueImpl(CSS_VAL_E_RESIZE);
+        case CURSOR_NE_RESIZE:
+            return new CSSPrimitiveValueImpl(CSS_VAL_NE_RESIZE);
+        case CURSOR_NW_RESIZE:
+            return new CSSPrimitiveValueImpl(CSS_VAL_NW_RESIZE);
+        case CURSOR_N_RESIZE:
+            return new CSSPrimitiveValueImpl(CSS_VAL_N_RESIZE);
+        case CURSOR_SE_RESIZE:
+            return new CSSPrimitiveValueImpl(CSS_VAL_SE_RESIZE);
+        case CURSOR_SW_RESIZE:
+            return new CSSPrimitiveValueImpl(CSS_VAL_SW_RESIZE);
+        case CURSOR_S_RESIZE:
+            return new CSSPrimitiveValueImpl(CSS_VAL_S_RESIZE);
+        case CURSOR_W_RESIZE:
+            return new CSSPrimitiveValueImpl(CSS_VAL_W_RESIZE);
+        case CURSOR_TEXT:
+            return new CSSPrimitiveValueImpl(CSS_VAL_TEXT);
+        case CURSOR_WAIT:
+            return new CSSPrimitiveValueImpl(CSS_VAL_WAIT);
+        case CURSOR_HELP:
+            return new CSSPrimitiveValueImpl(CSS_VAL_HELP);
+        }
+        Q_ASSERT(0);
+        break;
+    case CSS_PROP_DIRECTION:
+        switch (style->direction()) {
+        case LTR:
+            return new CSSPrimitiveValueImpl(CSS_VAL_LTR);
+        case RTL:
+            return new CSSPrimitiveValueImpl(CSS_VAL_RTL);
+        }
+        Q_ASSERT(0);
+        break;
+    case CSS_PROP_DISPLAY:
+        switch (style->display()) {
+        case INLINE:
+            return new CSSPrimitiveValueImpl(CSS_VAL_INLINE);
+        case BLOCK:
+            return new CSSPrimitiveValueImpl(CSS_VAL_BLOCK);
+        case LIST_ITEM:
+            return new CSSPrimitiveValueImpl(CSS_VAL_LIST_ITEM);
+        case RUN_IN:
+            return new CSSPrimitiveValueImpl(CSS_VAL_RUN_IN);
+        case COMPACT:
+            return new CSSPrimitiveValueImpl(CSS_VAL_COMPACT);
+        case INLINE_BLOCK:
+            return new CSSPrimitiveValueImpl(CSS_VAL_INLINE_BLOCK);
+        case TABLE:
+            return new CSSPrimitiveValueImpl(CSS_VAL_TABLE);
+        case INLINE_TABLE:
+            return new CSSPrimitiveValueImpl(CSS_VAL_INLINE_TABLE);
+        case TABLE_ROW_GROUP:
+            return new CSSPrimitiveValueImpl(CSS_VAL_TABLE_ROW_GROUP);
+        case TABLE_HEADER_GROUP:
+            return new CSSPrimitiveValueImpl(CSS_VAL_TABLE_HEADER_GROUP);
+        case TABLE_FOOTER_GROUP:
+            return new CSSPrimitiveValueImpl(CSS_VAL_TABLE_FOOTER_GROUP);
+        case TABLE_ROW:
+            return new CSSPrimitiveValueImpl(CSS_VAL_TABLE_ROW);
+        case TABLE_COLUMN_GROUP:
+            return new CSSPrimitiveValueImpl(CSS_VAL_TABLE_COLUMN_GROUP);
+        case TABLE_COLUMN:
+            return new CSSPrimitiveValueImpl(CSS_VAL_TABLE_COLUMN);
+        case TABLE_CELL:
+            return new CSSPrimitiveValueImpl(CSS_VAL_TABLE_CELL);
+        case TABLE_CAPTION:
+            return new CSSPrimitiveValueImpl(CSS_VAL_TABLE_CAPTION);
+        case NONE:
+            return new CSSPrimitiveValueImpl(CSS_VAL_NONE);
+        }
+        Q_ASSERT( 0 );
+        break;
+    case CSS_PROP_EMPTY_CELLS:
+        switch (style->emptyCells()) {
+        case SHOW:
+            return new CSSPrimitiveValueImpl(CSS_VAL_SHOW);
+        case HIDE:
+            return new CSSPrimitiveValueImpl(CSS_VAL_HIDE);
+        }
+        Q_ASSERT( 0 );
+        break;
+    case CSS_PROP_FLOAT:
+    {
+        switch (style->floating()) {
+        case FNONE:
+            return new CSSPrimitiveValueImpl(CSS_VAL_NONE);
+        case FLEFT:
+            return new CSSPrimitiveValueImpl(CSS_VAL_LEFT);
+        case FRIGHT:
+            return new CSSPrimitiveValueImpl(CSS_VAL_RIGHT);
+        case FLEFT_ALIGN:
+            return new CSSPrimitiveValueImpl(CSS_VAL__KHTML_LEFT);
+        case FRIGHT_ALIGN:
+            return new CSSPrimitiveValueImpl(CSS_VAL__KHTML_RIGHT);
+        }
+    }
+    case CSS_PROP_FONT_FAMILY:
+    {
+        FontDef def = style->htmlFont().getFontDef();
+        return new CSSPrimitiveValueImpl(def.family, CSSPrimitiveValue::CSS_STRING);
+    }
+    case CSS_PROP_FONT_SIZE:
+    {
+        FontDef def = style->htmlFont().getFontDef();
+        return new CSSPrimitiveValueImpl(def.size, CSSPrimitiveValue::CSS_PX);
+    }
+    case CSS_PROP_FONT_STYLE:
+    {
+        // FIXME: handle oblique
+        FontDef def = style->htmlFont().getFontDef();
+        if (def.italic)
+            return new CSSPrimitiveValueImpl(CSS_VAL_ITALIC);
+        else
+            return new CSSPrimitiveValueImpl(CSS_VAL_NORMAL);
+    }
+    case CSS_PROP_FONT_VARIANT:
+    {
+        FontDef def = style->htmlFont().getFontDef();
+        if (def.smallCaps)
+            return new CSSPrimitiveValueImpl(CSS_VAL_SMALL_CAPS);
+        else
+            return new CSSPrimitiveValueImpl(CSS_VAL_NORMAL);
+    }
+    case CSS_PROP_FONT_WEIGHT:
+    {
+        // FIXME: this does not reflect the full range of weights
+        // that can be expressed with CSS
+        FontDef def = style->htmlFont().getFontDef();
+        if (def.weight == TQFont::Bold)
+            return new CSSPrimitiveValueImpl(CSS_VAL_BOLD);
+        else
+            return new CSSPrimitiveValueImpl(CSS_VAL_NORMAL);
+    }
+    case CSS_PROP_HEIGHT:
+        return new CSSPrimitiveValueImpl(renderer->contentHeight(), CSSPrimitiveValue::CSS_PX);
+    case CSS_PROP_LEFT:
+        return getPositionOffsetValue(renderer, CSS_PROP_LEFT);
+    case CSS_PROP_LETTER_SPACING:
+        if (style->letterSpacing() == 0)
+            return new CSSPrimitiveValueImpl(CSS_VAL_NORMAL);
+        return new CSSPrimitiveValueImpl(style->letterSpacing(), CSSPrimitiveValue::CSS_PX);
+    case CSS_PROP_LINE_HEIGHT:
+    {
+        // Note: internally a specified <number> value gets encoded as a percentage,
+        // so the isPercent() case corresponds to the <number> case; 
+        // values < 0  are used to mark "normal"; and specified %%
+        // get computed down to px by the time they get to RenderStyle 
+        // already
+        Length length(style->lineHeight());
+        if (length.value() < 0) 
+            return new CSSPrimitiveValueImpl(CSS_VAL_NORMAL);
+        if (length.isPercent()) {
+            //XXX: merge from webcore the computedStyle/specifiedStyle distinction in rendering/font.h
+            float computedSize = style->htmlFont().getFontDef().size;
+            return new CSSPrimitiveValueImpl((int)(length.value() * computedSize) / 100, CSSPrimitiveValue::CSS_PX);
+        }
+        else {
+            return new CSSPrimitiveValueImpl(length.value(), CSSPrimitiveValue::CSS_PX);
+        }
+    }
+    case CSS_PROP_LIST_STYLE_IMAGE:
+        if (style->listStyleImage())
+            return new CSSPrimitiveValueImpl(style->listStyleImage()->url(), CSSPrimitiveValue::CSS_URI);
+        return new CSSPrimitiveValueImpl(CSS_VAL_NONE);
+    case CSS_PROP_LIST_STYLE_POSITION:
+        switch (style->listStylePosition()) {
+        case OUTSIDE:
+            return new CSSPrimitiveValueImpl(CSS_VAL_OUTSIDE);
+        case INSIDE:
+            return new CSSPrimitiveValueImpl(CSS_VAL_INSIDE);
+        }
+        Q_ASSERT( 0 );
+        break;
+    case CSS_PROP_LIST_STYLE_TYPE:
+        return new CSSPrimitiveValueImpl(stringForListStyleType(style->listStyleType()), CSSPrimitiveValue::CSS_STRING);
+    case CSS_PROP_MARGIN_TOP:
+        return valueForLength(style->marginTop(), renderer->contentHeight());
+    case CSS_PROP_MARGIN_RIGHT:
+        return valueForLength(style->marginRight(), renderer->contentWidth());
+    case CSS_PROP_MARGIN_BOTTOM:
+        return valueForLength(style->marginBottom(), renderer->contentHeight());
+    case CSS_PROP_MARGIN_LEFT:
+        return valueForLength(style->marginLeft(), renderer->contentWidth());
+    case CSS_PROP__KHTML_MARQUEE:
+        // FIXME: unimplemented
+        break;
+    case CSS_PROP__KHTML_MARQUEE_DIRECTION:
+        switch (style->marqueeDirection()) {
+        case MFORWARD:
+            return new CSSPrimitiveValueImpl(CSS_VAL_FORWARDS);
+        case MBACKWARD:
+            return new CSSPrimitiveValueImpl(CSS_VAL_BACKWARDS);
+        case MAUTO:
+            return new CSSPrimitiveValueImpl(CSS_VAL_AUTO);
+        case MUP:
+            return new CSSPrimitiveValueImpl(CSS_VAL_UP);
+        case MDOWN:
+            return new CSSPrimitiveValueImpl(CSS_VAL_DOWN);
+        case MLEFT:
+            return new CSSPrimitiveValueImpl(CSS_VAL_LEFT);
+        case MRIGHT:
+            return new CSSPrimitiveValueImpl(CSS_VAL_RIGHT);
+        }
+        Q_ASSERT(0);
+        return 0;
+    case CSS_PROP__KHTML_MARQUEE_INCREMENT:
+        return valueForLength(style->marqueeIncrement(), renderer->contentWidth());
+    case CSS_PROP__KHTML_MARQUEE_REPETITION:
+        if (style->marqueeLoopCount() < 0)
+            return new CSSPrimitiveValueImpl(CSS_VAL_INFINITE);
+        return new CSSPrimitiveValueImpl(style->marqueeLoopCount(), CSSPrimitiveValue::CSS_NUMBER);
+    case CSS_PROP__KHTML_MARQUEE_SPEED:
+        // FIXME: unimplemented
+        break;
+    case CSS_PROP__KHTML_MARQUEE_STYLE:
+        switch (style->marqueeBehavior()) {
+        case MNONE:
+            return new CSSPrimitiveValueImpl(CSS_VAL_NONE);
+        case MSCROLL:
+            return new CSSPrimitiveValueImpl(CSS_VAL_SCROLL);
+        case MSLIDE:
+            return new CSSPrimitiveValueImpl(CSS_VAL_SLIDE);
+        case MALTERNATE:
+            return new CSSPrimitiveValueImpl(CSS_VAL_ALTERNATE);
+        case MUNFURL:
+            return new CSSPrimitiveValueImpl(CSS_VAL_UNFURL);
+        }
+        Q_ASSERT(0);
+        return 0;
+    case CSS_PROP_MAX_HEIGHT:
+        return new CSSPrimitiveValueImpl( renderer->availableHeight(),
+                                          CSSPrimitiveValue::CSS_PX );
+        break;
+    case CSS_PROP_MAX_WIDTH:
+        return new CSSPrimitiveValueImpl( renderer->maxWidth(),
+                                          CSSPrimitiveValue::CSS_PX );
+        break;
+    case CSS_PROP_MIN_HEIGHT:
+        return new CSSPrimitiveValueImpl( renderer->contentHeight(),
+                                          CSSPrimitiveValue::CSS_PX );
+        break;
+    case CSS_PROP_MIN_WIDTH:
+        return new CSSPrimitiveValueImpl( renderer->minWidth(),
+                                          CSSPrimitiveValue::CSS_PX );
+        break;
+    case CSS_PROP_OPACITY:
+        return new CSSPrimitiveValueImpl(style->opacity(), CSSPrimitiveValue::CSS_NUMBER);
+    case CSS_PROP_ORPHANS:
+        return new CSSPrimitiveValueImpl(style->orphans(), CSSPrimitiveValue::CSS_NUMBER);
+    case CSS_PROP_OUTLINE_COLOR:
+        break;
+    case CSS_PROP_OUTLINE_OFFSET:
+        break;
+    case CSS_PROP_OUTLINE_STYLE:
+        if (style->outlineStyleIsAuto())
+            return new CSSPrimitiveValueImpl(CSS_VAL_AUTO);
+        return valueForBorderStyle(style->outlineStyle());
+    case CSS_PROP_OUTLINE_WIDTH:
+        break;
+    case CSS_PROP_OVERFLOW:
+    case CSS_PROP_OVERFLOW_X:
+    case CSS_PROP_OVERFLOW_Y: {
+        EOverflow overflow;
+        switch (propertyID) {
+        case CSS_PROP_OVERFLOW_X:
+            overflow = style->overflowX();
+            break;
+        case CSS_PROP_OVERFLOW_Y:
+            overflow = style->overflowY();
+            break;
+        default:
+            overflow = kMax(style->overflowX(), style->overflowY());
+        }
+        switch (overflow) {
+        case OVISIBLE:
+            return new CSSPrimitiveValueImpl(CSS_VAL_VISIBLE);
+        case OHIDDEN:
+            return new CSSPrimitiveValueImpl(CSS_VAL_HIDDEN);
+        case OSCROLL:
+            return new CSSPrimitiveValueImpl(CSS_VAL_SCROLL);
+        case OAUTO:
+            return new CSSPrimitiveValueImpl(CSS_VAL_AUTO);
+        case OMARQUEE:
+            return new CSSPrimitiveValueImpl(CSS_VAL_MARQUEE);
+        }
+        Q_ASSERT(0);
+        return 0;
+    }
+    case CSS_PROP_PADDING_TOP:
+        return valueForLength(style->paddingTop(), renderer->contentHeight());
+    case CSS_PROP_PADDING_RIGHT:
+        return valueForLength(style->paddingRight(), renderer->contentWidth());
+    case CSS_PROP_PADDING_BOTTOM:
+        return valueForLength(style->paddingBottom(), renderer->contentHeight());
+    case CSS_PROP_PADDING_LEFT:
+        return valueForLength(style->paddingLeft(), renderer->contentWidth());
+    case CSS_PROP_PAGE_BREAK_AFTER:
+        switch (style->pageBreakAfter()) {
+        case PBAUTO:
+            return new CSSPrimitiveValueImpl(CSS_VAL_AUTO);
+        case PBALWAYS:
+            return new CSSPrimitiveValueImpl(CSS_VAL_ALWAYS);
+        case PBAVOID:
+            return new CSSPrimitiveValueImpl(CSS_VAL_AVOID);
+        case PBLEFT:
+            return new CSSPrimitiveValueImpl(CSS_VAL_LEFT);
+        case PBRIGHT:
+            return new CSSPrimitiveValueImpl(CSS_VAL_RIGHT);
+        }
+        Q_ASSERT(0);
+        break;
+    case CSS_PROP_PAGE_BREAK_BEFORE:
+        switch (style->pageBreakBefore()) {
+        case PBAUTO:
+            return new CSSPrimitiveValueImpl(CSS_VAL_AUTO);
+        case PBALWAYS:
+            return new CSSPrimitiveValueImpl(CSS_VAL_ALWAYS);
+        case PBAVOID:
+            return new CSSPrimitiveValueImpl(CSS_VAL_AVOID);
+        case PBLEFT:
+            return new CSSPrimitiveValueImpl(CSS_VAL_LEFT);
+        case PBRIGHT:
+            return new CSSPrimitiveValueImpl(CSS_VAL_RIGHT);
+        }
+        Q_ASSERT(0);
+        break;
+    case CSS_PROP_PAGE_BREAK_INSIDE:
+        if (style->pageBreakInside())
+            return new CSSPrimitiveValueImpl(CSS_VAL_AUTO);
+        else
+            return new CSSPrimitiveValueImpl(CSS_VAL_AVOID);
+        Q_ASSERT(0);
+        break;
+    case CSS_PROP_POSITION:
+        switch (style->position()) {
+        case STATIC:
+            return new CSSPrimitiveValueImpl(CSS_VAL_STATIC);
+        case RELATIVE:
+            return new CSSPrimitiveValueImpl(CSS_VAL_RELATIVE);
+        case ABSOLUTE:
+            return new CSSPrimitiveValueImpl(CSS_VAL_ABSOLUTE);
+        case FIXED:
+            return new CSSPrimitiveValueImpl(CSS_VAL_FIXED);
+        }
+        Q_ASSERT(0);
+        break;
+    case CSS_PROP_QUOTES:
+        break;
+    case CSS_PROP_RIGHT:
+        return getPositionOffsetValue(renderer, CSS_PROP_RIGHT);
+    case CSS_PROP_SIZE:
+        break;
+    case CSS_PROP_TABLE_LAYOUT:
+        switch (style->tableLayout()) {
+        case TAUTO:
+            return new CSSPrimitiveValueImpl(CSS_VAL_AUTO);
+        case TFIXED:
+            return new CSSPrimitiveValueImpl(CSS_VAL_FIXED);
+        }
+        Q_ASSERT(0);
+        break;
+    case CSS_PROP_TEXT_ALIGN:
+        return valueForTextAlign(style->textAlign());
+    case CSS_PROP_TEXT_DECORATION:
+    {
+        TQString string;
+        if (style->textDecoration() & tdehtml::UNDERLINE)
+            string += "underline";
+        if (style->textDecoration() & tdehtml::OVERLINE) {
+            if (string.length() > 0)
+                string += " ";
+            string += "overline";
+        }
+        if (style->textDecoration() & tdehtml::LINE_THROUGH) {
+            if (string.length() > 0)
+                string += " ";
+            string += "line-through";
+        }
+        if (style->textDecoration() & tdehtml::BLINK) {
+            if (string.length() > 0)
+                string += " ";
+            string += "blink";
+        }
+        if (string.length() == 0)
+            string = "none";
+        return new CSSPrimitiveValueImpl(string, CSSPrimitiveValue::CSS_STRING);
+    }
+    case CSS_PROP_TEXT_INDENT:
+        return valueForLength(style->textIndent(), renderer->contentWidth());
+    case CSS_PROP_TEXT_SHADOW:
+        return valueForShadow(style->textShadow());
+    case CSS_PROP_TEXT_TRANSFORM:
+        switch (style->textTransform()) {
+        case CAPITALIZE:
+            return new CSSPrimitiveValueImpl(CSS_VAL_CAPITALIZE);
+        case UPPERCASE:
+            return new CSSPrimitiveValueImpl(CSS_VAL_UPPERCASE);
+        case LOWERCASE:
+            return new CSSPrimitiveValueImpl(CSS_VAL_LOWERCASE);
+        case TTNONE:
+            return new CSSPrimitiveValueImpl(CSS_VAL_NONE);
+        }
+        Q_ASSERT(0);
+        break;
+    case CSS_PROP_TOP:
+        return getPositionOffsetValue(renderer, CSS_PROP_TOP);
+    case CSS_PROP_UNICODE_BIDI:
+        switch (style->unicodeBidi()) {
+        case UBNormal:
+            return new CSSPrimitiveValueImpl(CSS_VAL_NORMAL);
+        case Embed:
+            return new CSSPrimitiveValueImpl(CSS_VAL_EMBED);
+        case Override:
+            return new CSSPrimitiveValueImpl(CSS_VAL_BIDI_OVERRIDE);
+        }
+        Q_ASSERT(0);
+        break;
+    case CSS_PROP_VERTICAL_ALIGN:
+    {
+        switch (style->verticalAlign()) {
+        case BASELINE:
+            return new CSSPrimitiveValueImpl(CSS_VAL_BASELINE);
+        case MIDDLE:
+            return new CSSPrimitiveValueImpl(CSS_VAL_MIDDLE);
+        case SUB:
+            return new CSSPrimitiveValueImpl(CSS_VAL_SUB);
+        case SUPER:
+            return new CSSPrimitiveValueImpl(CSS_VAL_SUPER);
+        case TEXT_TOP:
+            return new CSSPrimitiveValueImpl(CSS_VAL_TEXT_TOP);
+        case TEXT_BOTTOM:
+            return new CSSPrimitiveValueImpl(CSS_VAL_TEXT_BOTTOM);
+        case TOP:
+            return new CSSPrimitiveValueImpl(CSS_VAL_TOP);
+        case BOTTOM:
+            return new CSSPrimitiveValueImpl(CSS_VAL_BOTTOM);
+        case BASELINE_MIDDLE:
+            return new CSSPrimitiveValueImpl(CSS_VAL__KHTML_BASELINE_MIDDLE);
+        case LENGTH:
+            return valueForLength(style->verticalAlignLength(), renderer->contentWidth());
+        }
+        Q_ASSERT(0);
+        break;
+    }
+    case CSS_PROP_VISIBILITY:
+        switch (style->visibility()) {
+            case tdehtml::VISIBLE:
+                return new CSSPrimitiveValueImpl(CSS_VAL_VISIBLE);
+            case tdehtml::HIDDEN:
+                return new CSSPrimitiveValueImpl(CSS_VAL_HIDDEN);
+            case tdehtml::COLLAPSE:
+                return new CSSPrimitiveValueImpl(CSS_VAL_COLLAPSE);
+        }
+        Q_ASSERT(0);
+        break;
+    case CSS_PROP_WHITE_SPACE:
+    {
+        switch (style->whiteSpace()) {
+        case NORMAL:
+            return new CSSPrimitiveValueImpl(CSS_VAL_NORMAL);
+        case PRE:
+            return new CSSPrimitiveValueImpl(CSS_VAL_PRE);
+        case PRE_WRAP:
+            return new CSSPrimitiveValueImpl(CSS_VAL_PRE_WRAP);
+        case PRE_LINE:
+            return new CSSPrimitiveValueImpl(CSS_VAL_PRE_LINE);
+        case NOWRAP:
+            return new CSSPrimitiveValueImpl(CSS_VAL_NOWRAP);
+        case KHTML_NOWRAP:
+            return new CSSPrimitiveValueImpl(CSS_VAL__KHTML_NOWRAP);
+        }
+        Q_ASSERT(0);
+        break;
+    }
+    case CSS_PROP_WIDOWS:
+        return new CSSPrimitiveValueImpl(style->widows(), CSSPrimitiveValue::CSS_NUMBER);
+    case CSS_PROP_WIDTH:
+        return new CSSPrimitiveValueImpl( renderer->contentWidth(),
+                                         CSSPrimitiveValue::CSS_PX );
+    case CSS_PROP_WORD_SPACING:
+        return new CSSPrimitiveValueImpl(style->wordSpacing(), CSSPrimitiveValue::CSS_PX);
+    case CSS_PROP_Z_INDEX:
+        if (style->hasAutoZIndex())
+            return new CSSPrimitiveValueImpl(CSS_VAL_NORMAL);
+        return new CSSPrimitiveValueImpl(style->zIndex(), CSSPrimitiveValue::CSS_NUMBER);
+    case CSS_PROP_BACKGROUND:
+        break;
+    case CSS_PROP_BORDER:
+        break;
+    case CSS_PROP_BORDER_COLOR:
+        break;
+    case CSS_PROP_BORDER_STYLE:
+        break;
+    case CSS_PROP_BORDER_TOP:
+        return new CSSPrimitiveValueImpl( renderer->borderTop(),
+                                         CSSPrimitiveValue::CSS_PX );
+        break;
+    case CSS_PROP_BORDER_RIGHT:
+        return new CSSPrimitiveValueImpl( renderer->borderRight(),
+                                         CSSPrimitiveValue::CSS_PX );
+        break;
+    case CSS_PROP_BORDER_BOTTOM:
+        return new CSSPrimitiveValueImpl( renderer->borderBottom(),
+                                         CSSPrimitiveValue::CSS_PX );
+        break;
+    case CSS_PROP_BORDER_LEFT:
+        return new CSSPrimitiveValueImpl( renderer->borderLeft(),
+                                         CSSPrimitiveValue::CSS_PX );
+        break;
+    case CSS_PROP_BORDER_WIDTH:
+        break;
+    case CSS_PROP_FONT:
+        break;
+    case CSS_PROP_LIST_STYLE:
+        break;
+    case CSS_PROP_MARGIN:
+        break;
+    case CSS_PROP_OUTLINE:
+        break;
+    case CSS_PROP_PADDING:
+        break;
+    case CSS_PROP_SCROLLBAR_BASE_COLOR:
+        break;
+    case CSS_PROP_SCROLLBAR_FACE_COLOR:
+        break;
+    case CSS_PROP_SCROLLBAR_SHADOW_COLOR:
+        break;
+    case CSS_PROP_SCROLLBAR_HIGHLIGHT_COLOR:
+        break;
+    case CSS_PROP_SCROLLBAR_3DLIGHT_COLOR:
+        break;
+    case CSS_PROP_SCROLLBAR_DARKSHADOW_COLOR:
+        break;
+    case CSS_PROP_SCROLLBAR_TRACK_COLOR:
+        break;
+    case CSS_PROP_SCROLLBAR_ARROW_COLOR:
+        break;
+    case CSS_PROP__KHTML_FLOW_MODE:
+        break;
+    case CSS_PROP__KHTML_USER_INPUT:
+        break;
+    default:
+        Q_ASSERT( 0 );
+        break;
+    }
+    return 0;
+}
+
+DOMString RenderStyleDeclarationImpl::getPropertyValue( int propertyID ) const
+{
+    CSSValueImpl* value = getPropertyCSSValue(propertyID);
+    if (value) {
+        DOMString val = value->cssText();
+        delete value;
+        return val;
+    }
+    return "";
+}
+
+bool RenderStyleDeclarationImpl::getPropertyPriority( int ) const
+{
+    // All computed styles have a priority of false (not "important").
+    return false;
+}
+
+DOM::DOMString RenderStyleDeclarationImpl::removeProperty( int, bool )
+{
+    // ### emit error since we're read-only
+    return DOMString();
+}
+
+bool RenderStyleDeclarationImpl::setProperty ( int, const DOM::DOMString&, bool,
+                                               bool )
+{
+    // ### emit error since we're read-only
+    return false;
+}
+
+void RenderStyleDeclarationImpl::setProperty ( int, int, bool,
+                                               bool )
+{
+    // ### emit error since we're read-only
+}
+
+void RenderStyleDeclarationImpl::setLengthProperty( int, const DOM::DOMString&, bool,
+                                                    bool, bool )
+{
+    // ### emit error since we're read-only
+}
+
+void RenderStyleDeclarationImpl::setProperty( const DOMString& )
+{
+    // ### emit error since we're read-only
+}
+
+unsigned long RenderStyleDeclarationImpl::length() const
+{
+    return numComputedProperties;
+}
+
+DOM::DOMString RenderStyleDeclarationImpl::item( unsigned long i ) const
+{
+    if (i >= numComputedProperties)
+        return DOMString();
+
+    return getPropertyName(computedProperties[i]);
+}
+
+CSSProperty RenderStyleDeclarationImpl::property( int id ) const
+{
+    CSSProperty prop;
+    prop.m_id = id;
+    prop.m_important = false;
+    prop.nonCSSHint = false;
+
+    CSSValueImpl* v = getPropertyCSSValue( id );
+    if ( !v )
+        v = new CSSPrimitiveValueImpl;
+    prop.setValue( v );
+    return prop;
+}
+
diff --git a/tdehtml/css/css_renderstyledeclarationimpl.h b/tdehtml/css/css_renderstyledeclarationimpl.h
new file mode 100644
index 000000000..a751ceda1
--- /dev/null
+++ b/tdehtml/css/css_renderstyledeclarationimpl.h
@@ -0,0 +1,75 @@
+/*
+ * css_renderstyleimpl.h
+ *
+ * Copyright (C)  2004  Zack Rusin <zack@kde.org>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301  USA
+ */
+#ifndef CSS_RENDERSTYLEIMPL_H
+#define CSS_RENDERSTYLEIMPL_H
+
+#include "css/css_valueimpl.h"
+#include "dom/dom_string.h"
+#include "rendering/render_style.h"
+
+
+namespace DOM {
+    class NodeImpl;
+}
+
+namespace tdehtml {
+
+class RenderObject;
+
+
+// Used by DOM::Counter::listStyle()
+DOM::DOMString stringForListStyleType(tdehtml::EListStyleType type);
+
+class RenderStyleDeclarationImpl : public DOM::CSSStyleDeclarationImpl
+{
+public:
+    RenderStyleDeclarationImpl( DOM::NodeImpl *node );
+    virtual ~RenderStyleDeclarationImpl();
+
+    DOM::DOMString cssText() const;
+    void setCssText( DOM::DOMString str );
+
+    DOM::CSSValueImpl *getPropertyCSSValue( int propertyID ) const;
+    DOM::DOMString getPropertyValue( int propertyID ) const;
+    bool getPropertyPriority( int propertyID ) const;
+    unsigned long length() const;
+
+    DOM::DOMString removeProperty( int propertyID, bool NonCSSHints = false );
+    bool setProperty ( int propertyId, const DOM::DOMString &value, bool important = false,
+                       bool nonCSSHint = false);
+    void setProperty ( int propertyId, int value, bool important = false, bool nonCSSHint = false);
+    void setLengthProperty(int id, const DOM::DOMString &value, bool important,
+                           bool nonCSSHint = true, bool multiLength = false);
+
+    void setProperty ( const DOM::DOMString &propertyString);
+    DOM::DOMString item ( unsigned long index ) const;
+
+protected:
+    DOM::CSSProperty property( int id ) const;
+
+protected:
+    SharedPtr<DOM::NodeImpl> m_node;
+};
+
+
+}
+
+#endif
diff --git a/tdehtml/css/css_ruleimpl.cpp b/tdehtml/css/css_ruleimpl.cpp
new file mode 100644
index 000000000..0edd3a511
--- /dev/null
+++ b/tdehtml/css/css_ruleimpl.cpp
@@ -0,0 +1,391 @@
+/**
+ * This file is part of the DOM implementation for KDE.
+ *
+ * (C) 1999-2003 Lars Knoll (knoll@kde.org)
+ * (C) 2002-2003 Dirk Mueller (mueller@kde.org)
+ * Copyright (C) 2002 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 "dom/css_rule.h"
+#include "dom/css_stylesheet.h"
+#include "dom/dom_exception.h"
+#include "dom/dom_string.h"
+
+#include "css/css_stylesheetimpl.h"
+#include "css/css_valueimpl.h"
+#include "css/cssparser.h"
+#include "css/css_ruleimpl.h"
+
+#include "misc/loader.h"
+#include "misc/htmltags.h"
+#include "misc/htmlattrs.h"
+#include "xml/dom_docimpl.h"
+
+using namespace DOM;
+
+#include <kdebug.h>
+
+CSSStyleSheetImpl *CSSRuleImpl::parentStyleSheet() const
+{
+    return ( m_parent && m_parent->isCSSStyleSheet() )  ?
+	static_cast<CSSStyleSheetImpl *>(m_parent) : 0;
+}
+
+CSSRuleImpl *CSSRuleImpl::parentRule() const
+{
+    return ( m_parent && m_parent->isRule() )  ?
+	static_cast<CSSRuleImpl *>(m_parent) : 0;
+}
+
+DOM::DOMString CSSRuleImpl::cssText() const
+{
+    // ###
+    return DOMString();
+}
+
+void CSSRuleImpl::setCssText(DOM::DOMString /*str*/)
+{
+    // ###
+}
+
+// ---------------------------------------------------------------------------
+
+CSSFontFaceRuleImpl::CSSFontFaceRuleImpl(StyleBaseImpl *parent)
+    : CSSRuleImpl(parent)
+{
+    m_type = CSSRule::FONT_FACE_RULE;
+    m_style = 0;
+}
+
+CSSFontFaceRuleImpl::~CSSFontFaceRuleImpl()
+{
+    if(m_style) m_style->deref();
+}
+
+// --------------------------------------------------------------------------
+
+CSSImportRuleImpl::CSSImportRuleImpl( StyleBaseImpl *parent,
+                                      const DOM::DOMString &href,
+                                      MediaListImpl *media )
+    : CSSRuleImpl(parent)
+{
+    m_type = CSSRule::IMPORT_RULE;
+
+    m_lstMedia = media;
+    if ( !m_lstMedia )
+	m_lstMedia = new MediaListImpl( this, DOMString() );
+    m_lstMedia->setParent( this );
+    m_lstMedia->ref();
+
+    m_strHref = href;
+    m_styleSheet = 0;
+
+    m_cachedSheet = 0;
+
+    init();
+}
+CSSImportRuleImpl::CSSImportRuleImpl( StyleBaseImpl *parent,
+                                      const DOM::DOMString &href,
+                                      const DOM::DOMString &media )
+    : CSSRuleImpl(parent)
+{
+    m_type = CSSRule::IMPORT_RULE;
+
+    m_lstMedia = new MediaListImpl( this, media );
+    m_lstMedia->ref();
+
+    m_strHref = href;
+    m_styleSheet = 0;
+
+    m_cachedSheet = 0;
+
+    init();
+}
+
+CSSImportRuleImpl::~CSSImportRuleImpl()
+{
+    if( m_lstMedia ) {
+ 	m_lstMedia->setParent( 0 );
+	m_lstMedia->deref();
+    }
+    if(m_styleSheet) {
+        m_styleSheet->setParent(0);
+        m_styleSheet->deref();
+    }
+
+    if(m_cachedSheet) m_cachedSheet->deref(this);
+}
+
+void CSSImportRuleImpl::setStyleSheet(const DOM::DOMString &url, const DOM::DOMString &sheet, const DOM::DOMString &charset)
+{
+    if ( m_styleSheet ) {
+        m_styleSheet->setParent(0);
+        m_styleSheet->deref();
+    }
+    m_styleSheet = new CSSStyleSheetImpl(this, url);
+    m_styleSheet->setCharset(charset);
+    m_styleSheet->ref();
+
+    CSSStyleSheetImpl *parent = parentStyleSheet();
+    m_styleSheet->parseString( sheet, parent ? parent->useStrictParsing() : true );
+    m_loading = false;
+    m_done = true;
+
+    checkLoaded();
+}
+
+void CSSImportRuleImpl::error(int /*err*/, const TQString &/*text*/)
+{
+    if ( m_styleSheet ) {
+        m_styleSheet->setParent(0);
+        m_styleSheet->deref();
+    }
+    m_styleSheet = 0;
+
+    m_loading = false;
+    m_done = true;
+
+    checkLoaded();
+}
+
+bool CSSImportRuleImpl::isLoading()
+{
+    return ( m_loading || (m_styleSheet && m_styleSheet->isLoading()) );
+}
+
+void CSSImportRuleImpl::init()
+{
+    m_loading = 0;
+    m_done = false;
+    tdehtml::DocLoader *docLoader = 0;
+    StyleBaseImpl *root = this;
+    StyleBaseImpl *parent;
+    while ( ( parent = root->parent()) )
+	root = parent;
+    if (root->isCSSStyleSheet())
+	docLoader = static_cast<CSSStyleSheetImpl*>(root)->docLoader();
+
+    DOMString absHref = m_strHref;
+    CSSStyleSheetImpl *parentSheet = parentStyleSheet();
+    if (!parentSheet->href().isNull()) {
+      // use parent styleheet's URL as the base URL
+      absHref = KURL(KURL( parentSheet->href().string() ),m_strHref.string()).url();
+    }
+/*
+    else {
+      // use documents's URL as the base URL
+      DocumentImpl *doc = static_cast<CSSStyleSheetImpl*>(root)->doc();
+      absHref = KURL(doc->URL(),m_strHref.string()).url();
+    }
+*/
+    // Check for a cycle in our import chain.  If we encounter a stylesheet
+    // in our parent chain with the same URL, then just bail.
+    for ( parent = static_cast<StyleBaseImpl*>( this )->parent();
+         parent;
+         parent = parent->parent() )
+        if ( absHref == parent->baseURL().url() )
+            return;
+
+    m_cachedSheet = docLoader->requestStyleSheet(absHref, parentStyleSheet()->charset().string());
+
+    if (m_cachedSheet)
+    {
+      m_cachedSheet->ref(this);
+
+      // If the imported sheet is in the cache, then setStyleSheet gets called,
+      // and the sheet even gets parsed (via parseString).  In this case we have
+      // loaded (even if our subresources haven't), so if we have stylesheet after
+      // checking the cache, then we've clearly loaded. -dwh
+      // This can also happen when error() is called from within ref(). In either case,
+      // m_done is set to true.
+      if (!m_done)
+	m_loading = true;
+    }
+}
+
+// --------------------------------------------------------------------------
+CSSMediaRuleImpl::CSSMediaRuleImpl( StyleBaseImpl *parent, MediaListImpl *mediaList, CSSRuleListImpl *ruleList )
+    :   CSSRuleImpl( parent )
+{
+    m_type = CSSRule::MEDIA_RULE;
+    m_lstMedia = mediaList;
+    m_lstMedia->ref();
+    m_lstCSSRules = ruleList;
+    m_lstCSSRules->ref();
+}
+
+CSSMediaRuleImpl::CSSMediaRuleImpl(StyleBaseImpl *parent)
+    :   CSSRuleImpl( parent )
+{
+    m_type = CSSRule::MEDIA_RULE;
+    m_lstMedia = 0;
+    m_lstCSSRules = new CSSRuleListImpl();
+    m_lstCSSRules->ref();
+}
+
+CSSMediaRuleImpl::CSSMediaRuleImpl( StyleBaseImpl *parent, const DOM::DOMString &media )
+:   CSSRuleImpl( parent )
+{
+    m_type = CSSRule::MEDIA_RULE;
+    m_lstMedia = new MediaListImpl( this, media );
+    m_lstMedia->ref();
+    m_lstCSSRules = new CSSRuleListImpl();
+    m_lstCSSRules->ref();
+}
+
+CSSMediaRuleImpl::~CSSMediaRuleImpl()
+{
+    if( m_lstMedia ) {
+	m_lstMedia->setParent( 0 );
+        m_lstMedia->deref();
+    }
+    for ( unsigned int i = 0; i < m_lstCSSRules->length(); ++i )
+        m_lstCSSRules->item(  i )->setParent(  0 );
+    m_lstCSSRules->deref();
+}
+
+unsigned long CSSMediaRuleImpl::append( CSSRuleImpl *rule )
+{
+    return rule ? m_lstCSSRules->insertRule( rule, m_lstCSSRules->length() ) : 0;
+}
+
+unsigned long CSSMediaRuleImpl::insertRule( const DOMString &rule,
+                                            unsigned long index )
+{
+    CSSParser p( strictParsing );
+    CSSRuleImpl *newRule = p.parseRule( parentStyleSheet(), rule );
+
+    return newRule ? m_lstCSSRules->insertRule( newRule, index ) : 0;
+}
+
+CSSRuleListImpl::~CSSRuleListImpl()
+{
+    CSSRuleImpl* rule;
+    while ( !m_lstCSSRules.isEmpty() && ( rule = m_lstCSSRules.take( 0 ) ) )
+        rule->deref();
+}
+
+// ---------------------------------------------------------------------------
+
+CSSPageRuleImpl::CSSPageRuleImpl(StyleBaseImpl *parent)
+    : CSSRuleImpl(parent)
+{
+    m_type = CSSRule::PAGE_RULE;
+    m_style = 0;
+}
+
+CSSPageRuleImpl::~CSSPageRuleImpl()
+{
+    if(m_style) m_style->deref();
+}
+
+DOM::DOMString CSSPageRuleImpl::selectorText() const
+{
+    // ###
+    return DOMString();
+}
+
+void CSSPageRuleImpl::setSelectorText(DOM::DOMString /*str*/)
+{
+    // ###
+}
+
+// --------------------------------------------------------------------------
+
+CSSStyleRuleImpl::CSSStyleRuleImpl(StyleBaseImpl *parent)
+    : CSSRuleImpl(parent)
+{
+    m_type = CSSRule::STYLE_RULE;
+    m_style = 0;
+    m_selector = 0;
+}
+
+CSSStyleRuleImpl::~CSSStyleRuleImpl()
+{
+    if(m_style) {
+	m_style->setParent( 0 );
+	m_style->deref();
+    }
+    delete m_selector;
+}
+
+DOM::DOMString CSSStyleRuleImpl::selectorText() const
+{
+    if (m_selector) {
+        DOMString str;
+        for (CSSSelector *s = m_selector->first(); s; s = m_selector->next()) {
+            if (s != m_selector->getFirst())
+                str += ", ";
+            str += s->selectorText();
+        }
+        return str;
+    }
+    return DOMString();
+}
+
+void CSSStyleRuleImpl::setSelectorText(DOM::DOMString /*str*/)
+{
+    // ###
+}
+
+bool CSSStyleRuleImpl::parseString( const DOMString &/*string*/, bool )
+{
+    // ###
+    return false;
+}
+
+void CSSStyleRuleImpl::setDeclaration( CSSStyleDeclarationImpl *style)
+{
+    if ( m_style != style ) {
+        if(m_style) m_style->deref();
+        m_style = style;
+        if(m_style) m_style->ref();
+    }
+}
+
+void CSSStyleRuleImpl::setNonCSSHints()
+{
+    CSSSelector *s = m_selector->first();
+    while ( s ) {
+	s->nonCSSHint = true;
+	s = m_selector->next();
+    }
+}
+
+void CSSRuleListImpl::deleteRule ( unsigned long index )
+{
+    CSSRuleImpl *rule = m_lstCSSRules.take( index );
+    if( rule )
+        rule->deref();
+    else {
+         // ### Throw INDEX_SIZE_ERR exception here (TODO)
+    }
+}
+
+unsigned long CSSRuleListImpl::insertRule( CSSRuleImpl *rule,
+                                           unsigned long index )
+{
+    if( rule && m_lstCSSRules.insert( index, rule ) )
+    {
+        rule->ref();
+        return index;
+    }
+
+    // ### Should throw INDEX_SIZE_ERR exception instead! (TODO)
+    return 0;
+}
+
diff --git a/tdehtml/css/css_ruleimpl.h b/tdehtml/css/css_ruleimpl.h
new file mode 100644
index 000000000..63d0f96a1
--- /dev/null
+++ b/tdehtml/css/css_ruleimpl.h
@@ -0,0 +1,237 @@
+/*
+ * This file is part of the DOM implementation for KDE.
+ *
+ * (C) 1999-2003 Lars Knoll (knoll@kde.org)
+ * (C) 2002-2003 Dirk Mueller (mueller@kde.org)
+ * Copyright (C) 2002 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 _CSS_css_ruleimpl_h_
+#define _CSS_css_ruleimpl_h_
+
+#include "dom/dom_string.h"
+#include "dom/css_rule.h"
+#include "css/css_base.h"
+#include "misc/loader_client.h"
+#include "misc/shared.h"
+
+namespace tdehtml {
+    class CachedCSSStyleSheet;
+}
+
+namespace DOM {
+
+class CSSRule;
+class CSSStyleSheet;
+class CSSStyleSheetImpl;
+class CSSStyleDeclarationImpl;
+class MediaListImpl;
+
+class CSSRuleImpl : public StyleBaseImpl
+{
+public:
+    CSSRuleImpl(StyleBaseImpl *parent)
+        : StyleBaseImpl(parent), m_type(CSSRule::UNKNOWN_RULE) {}
+
+    virtual bool isRule() const { return true; }
+    unsigned short type() const { return m_type; }
+
+    CSSStyleSheetImpl *parentStyleSheet() const;
+    CSSRuleImpl *parentRule() const;
+
+    DOM::DOMString cssText() const;
+    void setCssText(DOM::DOMString str);
+    virtual void init() {}
+
+protected:
+    CSSRule::RuleType m_type;
+};
+
+
+class CSSCharsetRuleImpl : public CSSRuleImpl
+{
+public:
+    CSSCharsetRuleImpl(StyleBaseImpl *parent)
+        : CSSRuleImpl(parent) { m_type = CSSRule::CHARSET_RULE; }
+
+    virtual bool isCharsetRule() const { return true; }
+
+    DOMString encoding() const { return m_encoding; }
+    void setEncoding(DOMString _encoding) { m_encoding = _encoding; }
+
+protected:
+    DOMString m_encoding;
+};
+
+
+class CSSFontFaceRuleImpl : public CSSRuleImpl
+{
+public:
+    CSSFontFaceRuleImpl(StyleBaseImpl *parent);
+
+    virtual ~CSSFontFaceRuleImpl();
+
+    CSSStyleDeclarationImpl *style() const { return m_style; }
+
+    virtual bool isFontFaceRule() const { return true; }
+
+protected:
+    CSSStyleDeclarationImpl *m_style;
+};
+
+
+class CSSImportRuleImpl : public tdehtml::CachedObjectClient, public CSSRuleImpl
+{
+public:
+    CSSImportRuleImpl( StyleBaseImpl *parent, const DOM::DOMString &href,
+                       const DOM::DOMString &media );
+    CSSImportRuleImpl( StyleBaseImpl *parent, const DOM::DOMString &href,
+                       MediaListImpl *media );
+
+    virtual ~CSSImportRuleImpl();
+
+    DOM::DOMString href() const { return m_strHref; }
+    MediaListImpl *media() const { return m_lstMedia; }
+    CSSStyleSheetImpl *styleSheet() const { return m_styleSheet; }
+
+    virtual bool isImportRule() const { return true; }
+
+    // from CachedObjectClient
+    virtual void setStyleSheet(const DOM::DOMString &url, const DOM::DOMString &sheet, const DOM::DOMString &charset);
+    virtual void error(int err, const TQString &text);
+
+    bool isLoading();
+    virtual void init();
+
+protected:
+    DOMString m_strHref;
+    MediaListImpl *m_lstMedia;
+    CSSStyleSheetImpl *m_styleSheet;
+    tdehtml::CachedCSSStyleSheet *m_cachedSheet;
+    bool m_loading;
+    bool m_done;
+};
+
+class MediaList;
+
+class CSSRuleListImpl : public tdehtml::Shared<CSSRuleListImpl>
+{
+public:
+    CSSRuleListImpl() {}
+
+    ~CSSRuleListImpl();
+
+    unsigned long length() const { return m_lstCSSRules.count(); }
+    CSSRuleImpl *item ( unsigned long index ) { return m_lstCSSRules.at( index ); }
+
+
+    /* not part of the DOM */
+    unsigned long insertRule ( CSSRuleImpl *rule, unsigned long index );
+    void deleteRule ( unsigned long index );
+
+    void append( CSSRuleImpl *rule ) { m_lstCSSRules.append( rule ); }
+protected:
+    TQPtrList<CSSRuleImpl> m_lstCSSRules;
+};
+
+class CSSMediaRuleImpl : public CSSRuleImpl
+{
+public:
+    CSSMediaRuleImpl( StyleBaseImpl *parent );
+    CSSMediaRuleImpl( StyleBaseImpl *parent, const DOM::DOMString &media );
+    CSSMediaRuleImpl( StyleBaseImpl *parent, MediaListImpl *mediaList, CSSRuleListImpl *ruleList );
+
+    virtual ~CSSMediaRuleImpl();
+
+    MediaListImpl *media() const { return m_lstMedia; }
+    CSSRuleListImpl *cssRules() { return m_lstCSSRules; }
+
+    unsigned long insertRule ( const DOM::DOMString &rule, unsigned long index );
+    void deleteRule ( unsigned long index ) { m_lstCSSRules->deleteRule( index ); }
+
+    virtual bool isMediaRule() const { return true; }
+
+    /* Not part of the DOM */
+    unsigned long append( CSSRuleImpl *rule );
+protected:
+    MediaListImpl *m_lstMedia;
+    CSSRuleListImpl *m_lstCSSRules;
+};
+
+
+class CSSPageRuleImpl : public CSSRuleImpl
+{
+public:
+    CSSPageRuleImpl(StyleBaseImpl *parent);
+
+    virtual ~CSSPageRuleImpl();
+
+    CSSStyleDeclarationImpl *style() const { return m_style; }
+
+    virtual bool isPageRule() const { return true; }
+
+    DOM::DOMString selectorText() const;
+    void setSelectorText(DOM::DOMString str);
+
+protected:
+    CSSStyleDeclarationImpl *m_style;
+};
+
+
+class CSSStyleRuleImpl : public CSSRuleImpl
+{
+public:
+    CSSStyleRuleImpl(StyleBaseImpl *parent);
+
+    virtual ~CSSStyleRuleImpl();
+
+    CSSStyleDeclarationImpl *style() const { return m_style; }
+
+    virtual bool isStyleRule() const { return true; }
+
+    DOM::DOMString selectorText() const;
+    void setSelectorText(DOM::DOMString str);
+
+    virtual bool parseString( const DOMString &string, bool = false );
+
+    void setSelector( TQPtrList<CSSSelector> *selector) { m_selector = selector; }
+    void setDeclaration( CSSStyleDeclarationImpl *style);
+
+    TQPtrList<CSSSelector> *selector() { return m_selector; }
+    CSSStyleDeclarationImpl *declaration() { return m_style; }
+
+    void setNonCSSHints();
+
+protected:
+    CSSStyleDeclarationImpl *m_style;
+    TQPtrList<CSSSelector> *m_selector;
+};
+
+
+class CSSUnknownRuleImpl : public CSSRuleImpl
+{
+public:
+    CSSUnknownRuleImpl(StyleBaseImpl *parent) : CSSRuleImpl(parent) {}
+
+    virtual bool isUnknownRule() const { return true; }
+};
+
+
+} // namespace
+
+#endif
diff --git a/tdehtml/css/css_stylesheetimpl.cpp b/tdehtml/css/css_stylesheetimpl.cpp
new file mode 100644
index 000000000..40fa0dc0c
--- /dev/null
+++ b/tdehtml/css/css_stylesheetimpl.cpp
@@ -0,0 +1,436 @@
+/**
+ * This file is part of the DOM implementation for KDE.
+ *
+ * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org)
+ *           (C) 2004 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.
+ *
+ */
+
+//#define CSS_STYLESHEET_DEBUG
+
+#include "dom/dom_string.h"
+#include "dom/dom_exception.h"
+#include "dom/css_stylesheet.h"
+#include "dom/css_rule.h"
+
+#include "css/css_ruleimpl.h"
+#include "css/css_valueimpl.h"
+#include "css/cssparser.h"
+#include "css/css_stylesheetimpl.h"
+
+#include "xml/dom_nodeimpl.h"
+#include "html/html_documentimpl.h"
+#include "misc/loader.h"
+
+#include <kdebug.h>
+
+using namespace DOM;
+using namespace tdehtml;
+// --------------------------------------------------------------------------------
+
+StyleSheetImpl::StyleSheetImpl(StyleSheetImpl *parentSheet, DOMString href)
+    : StyleListImpl(parentSheet)
+{
+    m_disabled = false;
+    m_media = 0;
+    m_parentNode = 0;
+    m_strHref = href;
+}
+
+
+StyleSheetImpl::StyleSheetImpl(DOM::NodeImpl *parentNode, DOMString href)
+    : StyleListImpl()
+{
+    m_parentNode = parentNode;
+    m_disabled = false;
+    m_media = 0;
+    m_strHref = href;
+}
+
+StyleSheetImpl::StyleSheetImpl(StyleBaseImpl *owner, DOMString href)
+    : StyleListImpl(owner)
+{
+    m_disabled = false;
+    m_media = 0;
+    m_parentNode = 0;
+    m_strHref = href;
+}
+
+StyleSheetImpl::~StyleSheetImpl()
+{
+    if(m_media) {
+	m_media->setParent( 0 );
+	m_media->deref();
+    }
+}
+
+StyleSheetImpl *StyleSheetImpl::parentStyleSheet() const
+{
+    if( !m_parent ) return 0;
+    if( m_parent->isStyleSheet() ) return static_cast<StyleSheetImpl *>(m_parent);
+    if( m_parent->isRule() ) return m_parent->stylesheet();
+    return 0;
+}
+
+void StyleSheetImpl::setMedia( MediaListImpl *media )
+{
+    if( media )
+	media->ref();
+    if( m_media )
+	m_media->deref();
+    m_media = media;
+}
+
+void StyleSheetImpl::setDisabled( bool disabled )
+{
+    bool updateStyle = isCSSStyleSheet() && m_parentNode && disabled != m_disabled;
+    m_disabled = disabled;
+    if (updateStyle)
+        m_parentNode->getDocument()->updateStyleSelector();
+}
+
+// -----------------------------------------------------------------------
+
+
+CSSStyleSheetImpl::CSSStyleSheetImpl(CSSStyleSheetImpl *parentSheet, DOMString href)
+    : StyleSheetImpl(parentSheet, href)
+{
+    m_lstChildren = new TQPtrList<StyleBaseImpl>;
+    m_doc = parentSheet ? parentSheet->doc() : 0;
+    m_implicit = false;
+    m_namespaces = 0;
+    m_defaultNamespace = anyNamespace;
+}
+
+CSSStyleSheetImpl::CSSStyleSheetImpl(DOM::NodeImpl *parentNode, DOMString href, bool _implicit)
+    : StyleSheetImpl(parentNode, href)
+{
+    m_lstChildren = new TQPtrList<StyleBaseImpl>;
+    m_doc = parentNode->getDocument();
+    m_implicit = _implicit;
+    m_namespaces = 0;
+    m_defaultNamespace = anyNamespace;
+}
+
+CSSStyleSheetImpl::CSSStyleSheetImpl(CSSRuleImpl *ownerRule, DOMString href)
+    : StyleSheetImpl(ownerRule, href)
+{
+    m_lstChildren = new TQPtrList<StyleBaseImpl>;
+    m_doc = static_cast<CSSStyleSheetImpl*>(ownerRule->stylesheet())->doc();
+    m_implicit = false;
+    m_namespaces = 0;
+    m_defaultNamespace = anyNamespace;
+}
+
+CSSStyleSheetImpl::CSSStyleSheetImpl(DOM::NodeImpl *parentNode, CSSStyleSheetImpl *orig)
+    : StyleSheetImpl(parentNode, orig->m_strHref)
+{
+    m_lstChildren = new TQPtrList<StyleBaseImpl>;
+    StyleBaseImpl *rule;
+    for ( rule = orig->m_lstChildren->first(); rule != 0; rule = orig->m_lstChildren->next() )
+    {
+        m_lstChildren->append(rule);
+        rule->setParent(this);
+    }
+    m_doc = parentNode->getDocument();
+    m_implicit = false;
+    m_namespaces = 0;
+    m_defaultNamespace = anyNamespace;
+}
+
+CSSStyleSheetImpl::CSSStyleSheetImpl(CSSRuleImpl *ownerRule, CSSStyleSheetImpl *orig)
+    : StyleSheetImpl(ownerRule, orig->m_strHref)
+{
+    // m_lstChildren is deleted in StyleListImpl
+    m_lstChildren = new TQPtrList<StyleBaseImpl>;
+    StyleBaseImpl *rule;
+    for ( rule = orig->m_lstChildren->first(); rule != 0; rule = orig->m_lstChildren->next() )
+    {
+        m_lstChildren->append(rule);
+        rule->setParent(this);
+    }
+    m_doc = static_cast<CSSStyleSheetImpl*>(ownerRule->stylesheet())->doc();
+    m_implicit = false;
+    m_namespaces = 0;
+    m_defaultNamespace = anyNamespace;
+}
+
+CSSRuleImpl *CSSStyleSheetImpl::ownerRule() const
+{
+    if( !m_parent ) return 0;
+    if( m_parent->isRule() ) return static_cast<CSSRuleImpl *>(m_parent);
+    return 0;
+}
+
+unsigned long CSSStyleSheetImpl::insertRule( const DOMString &rule, unsigned long index, int &exceptioncode )
+{
+    exceptioncode = 0;
+    if(index > m_lstChildren->count()) {
+        exceptioncode = DOMException::INDEX_SIZE_ERR;
+        return 0;
+    }
+    CSSParser p( strictParsing );
+    CSSRuleImpl *r = p.parseRule( this, rule );
+
+    if(!r) {
+        exceptioncode = CSSException::SYNTAX_ERR + CSSException::_EXCEPTION_OFFSET;
+        return 0;
+    }
+    // ###
+    // HIERARCHY_REQUEST_ERR: Raised if the rule cannot be inserted at the specified index e.g. if an
+    //@import rule is inserted after a standard rule set or other at-rule.
+    m_lstChildren->insert(index, r);
+    if (m_doc)
+        m_doc->updateStyleSelector(true /*shallow*/);
+    return index;
+}
+
+CSSRuleList CSSStyleSheetImpl::cssRules()
+{
+    return this;
+}
+
+void CSSStyleSheetImpl::deleteRule( unsigned long index, int &exceptioncode )
+{
+    exceptioncode = 0;
+    StyleBaseImpl *b = m_lstChildren->take(index);
+    if(!b) {
+        exceptioncode = DOMException::INDEX_SIZE_ERR;
+        return;
+    }
+    // TreeShared requires delete not deref when removed from tree
+    b->setParent(0);
+    if( !b->refCount() ) delete b;
+    if (m_doc)
+        m_doc->updateStyleSelector(true /*shallow*/);
+}
+
+void CSSStyleSheetImpl::addNamespace(CSSParser* p, const DOM::DOMString& prefix, const DOM::DOMString& uri)
+{
+    int exceptioncode = 0;
+    if (uri.isEmpty())
+        return;
+
+    m_namespaces = new CSSNamespace(prefix, uri, m_namespaces);
+
+    if (prefix.isEmpty()) {
+        Q_ASSERT(m_doc != 0);
+
+        m_defaultNamespace = m_doc->getId(NodeImpl::NamespaceId, uri.implementation(), false, false, &exceptioncode);
+    }
+}
+
+void CSSStyleSheetImpl::determineNamespace(TQ_UINT32& id, const DOM::DOMString& prefix)
+{
+    // If the stylesheet has no namespaces we can just return.  There won't be any need to ever check
+    // namespace values in selectors.
+    if (!m_namespaces)
+        return;
+
+    if (prefix.isEmpty())
+         id = makeId(emptyNamespace, localNamePart(id)); // No namespace. If an element/attribute has a namespace, we won't match it.
+    else if (prefix == "*")
+        id = makeId(anyNamespace, localNamePart(id)); // We'll match any namespace.
+    else {
+        int exceptioncode = 0;
+        CSSNamespace* ns = m_namespaces->namespaceForPrefix(prefix);
+        if (ns) {
+            Q_ASSERT(m_doc != 0);
+
+            // Look up the id for this namespace URI.
+            TQ_UINT16 nsid = m_doc->getId(NodeImpl::NamespaceId, 0, 0, ns->uri().implementation(), false, false, &exceptioncode);
+            id = makeId(nsid, localNamePart(id));
+        }
+    }
+}
+
+bool CSSStyleSheetImpl::parseString(const DOMString &string, bool strict)
+{
+#ifdef CSS_STYLESHEET_DEBUG
+    kdDebug( 6080 ) << "parsing sheet, len=" << string.length() << ", sheet is " << string.string() << endl;
+#endif
+
+    strictParsing = strict;
+    CSSParser p( strict );
+    p.parseSheet( this, string );
+    return true;
+}
+
+bool CSSStyleSheetImpl::isLoading() const
+{
+    StyleBaseImpl *rule;
+    for ( rule = m_lstChildren->first(); rule != 0; rule = m_lstChildren->next() )
+    {
+        if(rule->isImportRule())
+        {
+            CSSImportRuleImpl *import = static_cast<CSSImportRuleImpl *>(rule);
+#ifdef CSS_STYLESHEET_DEBUG
+            kdDebug( 6080 ) << "found import" << endl;
+#endif
+            if(import->isLoading())
+            {
+#ifdef CSS_STYLESHEET_DEBUG
+                kdDebug( 6080 ) << "--> not loaded" << endl;
+#endif
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+void CSSStyleSheetImpl::checkLoaded() const
+{
+    if(isLoading()) return;
+    if(m_parent) m_parent->checkLoaded();
+    if(m_parentNode) m_parentNode->sheetLoaded();
+}
+
+void CSSStyleSheetImpl::setNonCSSHints()
+{
+    StyleBaseImpl *rule = m_lstChildren->first();
+    while(rule) {
+        if(rule->isStyleRule()) {
+            static_cast<CSSStyleRuleImpl *>(rule)->setNonCSSHints();
+        }
+        rule = m_lstChildren->next();
+    }
+}
+
+
+// ---------------------------------------------------------------------------
+
+
+StyleSheetListImpl::~StyleSheetListImpl()
+{
+    for ( TQPtrListIterator<StyleSheetImpl> it ( styleSheets ); it.current(); ++it )
+        it.current()->deref();
+}
+
+void StyleSheetListImpl::add( StyleSheetImpl* s )
+{
+    if ( !styleSheets.containsRef( s ) ) {
+        s->ref();
+        styleSheets.append( s );
+    }
+}
+
+void StyleSheetListImpl::remove( StyleSheetImpl* s )
+{
+    if ( styleSheets.removeRef( s ) )
+        s->deref();
+}
+
+unsigned long StyleSheetListImpl::length() const
+{
+    // hack so implicit BODY stylesheets don't get counted here
+    unsigned long l = 0;
+    TQPtrListIterator<StyleSheetImpl> it(styleSheets);
+    for (; it.current(); ++it) {
+        if (!it.current()->isCSSStyleSheet() || !static_cast<CSSStyleSheetImpl*>(it.current())->implicit())
+            ++l;
+    }
+    return l;
+}
+
+StyleSheetImpl *StyleSheetListImpl::item ( unsigned long index )
+{
+    unsigned long l = 0;
+    TQPtrListIterator<StyleSheetImpl> it(styleSheets);
+    for (; it.current(); ++it) {
+        if (!it.current()->isCSSStyleSheet() || !static_cast<CSSStyleSheetImpl*>(it.current())->implicit()) {
+            if (l == index)
+                return it.current();
+            ++l;
+        }
+    }
+    return 0;
+}
+
+// --------------------------------------------------------------------------------------------
+
+MediaListImpl::MediaListImpl( CSSStyleSheetImpl *parentSheet,
+                              const DOMString &media )
+    : StyleBaseImpl( parentSheet )
+{
+    setMediaText( media );
+}
+
+MediaListImpl::MediaListImpl( CSSRuleImpl *parentRule, const DOMString &media )
+    : StyleBaseImpl(parentRule)
+{
+    setMediaText( media );
+}
+
+bool MediaListImpl::contains( const DOMString &medium ) const
+{
+    return m_lstMedia.empty() || m_lstMedia.contains( medium ) ||
+            m_lstMedia.contains( "all" );
+}
+
+CSSStyleSheetImpl *MediaListImpl::parentStyleSheet() const
+{
+    if( m_parent->isCSSStyleSheet() ) return static_cast<CSSStyleSheetImpl *>(m_parent);
+    return 0;
+}
+
+CSSRuleImpl *MediaListImpl::parentRule() const
+{
+    if( m_parent->isRule() ) return static_cast<CSSRuleImpl *>(m_parent);
+    return 0;
+}
+
+void MediaListImpl::deleteMedium( const DOMString &oldMedium )
+{
+    const TQValueList<DOMString>::Iterator itEnd = m_lstMedia.end();
+
+    for ( TQValueList<DOMString>::Iterator it = m_lstMedia.begin(); it != itEnd; ++it ) {
+        if( (*it) == oldMedium ) {
+            m_lstMedia.remove( it );
+            return;
+        }
+    }
+}
+
+DOM::DOMString MediaListImpl::mediaText() const
+{
+    DOMString text;
+    const TQValueList<DOMString>::ConstIterator itEnd = m_lstMedia.end();
+
+    for ( TQValueList<DOMString>::ConstIterator it = m_lstMedia.begin(); it != itEnd; ++it ) {
+        text += *it;
+        text += ", ";
+    }
+    return text;
+}
+
+void MediaListImpl::setMediaText(const DOM::DOMString &value)
+{
+    m_lstMedia.clear();
+    const TQString val = value.string();
+    const TQStringList list = TQStringList::split( ',', val );
+
+    const TQStringList::ConstIterator itEnd = list.end();
+
+    for ( TQStringList::ConstIterator it = list.begin(); it != itEnd; ++it )
+    {
+        const DOMString medium = (*it).stripWhiteSpace();
+        if( !medium.isEmpty() )
+            m_lstMedia.append( medium );
+    }
+}
diff --git a/tdehtml/css/css_stylesheetimpl.h b/tdehtml/css/css_stylesheetimpl.h
new file mode 100644
index 000000000..8b59003ed
--- /dev/null
+++ b/tdehtml/css/css_stylesheetimpl.h
@@ -0,0 +1,192 @@
+/*
+ * This file is part of the DOM implementation for KDE.
+ *
+ * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org)
+ *           (C) 2004 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 _CSS_css_stylesheetimpl_h_
+#define _CSS_css_stylesheetimpl_h_
+
+#include <tqvaluelist.h>
+#include <tqptrlist.h>
+
+#include "dom/dom_string.h"
+#include "css/css_base.h"
+#include "misc/loader_client.h"
+#include "xml/dom_docimpl.h"
+
+namespace tdehtml {
+    class CachedCSSStyleSheet;
+    class DocLoader;
+}
+
+namespace DOM {
+
+class StyleSheet;
+class CSSStyleSheet;
+class CSSParser;
+class MediaListImpl;
+class CSSRuleImpl;
+class CSSRuleList;
+class CSSStyleRuleImpl;
+class CSSValueImpl;
+class NodeImpl;
+class DocumentImpl;
+
+class StyleSheetImpl : public StyleListImpl
+{
+public:
+    StyleSheetImpl(DOM::NodeImpl *ownerNode, DOM::DOMString href = DOMString());
+    StyleSheetImpl(StyleSheetImpl *parentSheet, DOM::DOMString href = DOMString());
+    StyleSheetImpl(StyleBaseImpl *owner, DOM::DOMString href  = DOMString());
+    StyleSheetImpl(tdehtml::CachedCSSStyleSheet *cached, DOM::DOMString href  = DOMString());
+    virtual ~StyleSheetImpl();
+
+    virtual bool isStyleSheet() const { return true; }
+
+    virtual DOM::DOMString type() const { return DOMString(); }
+
+    bool disabled() const { return m_disabled; }
+    void setDisabled( bool disabled );
+    DOM::NodeImpl *ownerNode() const { return m_parentNode; }
+    StyleSheetImpl *parentStyleSheet() const;
+    DOM::DOMString href() const { return m_strHref; }
+    DOM::DOMString title() const { return m_strTitle; }
+    MediaListImpl *media() const { return m_media; }
+    void setMedia( MediaListImpl *media );
+
+protected:
+    DOM::NodeImpl *m_parentNode;
+    DOM::DOMString m_strHref;
+    DOM::DOMString m_strTitle;
+    MediaListImpl *m_media;
+    bool m_disabled;
+};
+
+class CSSStyleSheetImpl : public StyleSheetImpl
+{
+public:
+    CSSStyleSheetImpl(DOM::NodeImpl *parentNode, DOM::DOMString href = DOMString(), bool _implicit = false);
+    CSSStyleSheetImpl(CSSStyleSheetImpl *parentSheet, DOM::DOMString href = DOMString());
+    CSSStyleSheetImpl(CSSRuleImpl *ownerRule, DOM::DOMString href = DOMString());
+    // clone from a cached version of the sheet
+    CSSStyleSheetImpl(DOM::NodeImpl *parentNode, CSSStyleSheetImpl *orig);
+    CSSStyleSheetImpl(CSSRuleImpl *ownerRule, CSSStyleSheetImpl *orig);
+
+    ~CSSStyleSheetImpl() { delete m_namespaces; }
+
+    virtual bool isCSSStyleSheet() const { return true; }
+
+    virtual DOM::DOMString type() const { return "text/css"; }
+
+    CSSRuleImpl *ownerRule() const;
+    CSSRuleList cssRules();
+    unsigned long insertRule ( const DOM::DOMString &rule, unsigned long index, int &exceptioncode );
+    void deleteRule ( unsigned long index, int &exceptioncode );
+
+    void addNamespace(CSSParser* p, const DOM::DOMString& prefix, const DOM::DOMString& uri);
+    void determineNamespace(TQ_UINT32& id, const DOM::DOMString& prefix);
+    TQ_UINT32 defaultNamespace() { return m_defaultNamespace; };
+
+    void setCharset(const DOMString &charset) { m_charset = charset; }
+    const DOMString& charset() const { return m_charset; }
+
+    virtual bool parseString( const DOMString &string, bool strict = true );
+
+    bool isLoading() const;
+    void setNonCSSHints();
+
+    virtual void checkLoaded() const;
+
+    // ### remove? (clients should use sheet->doc()->docLoader())
+    tdehtml::DocLoader *docLoader() const
+    { return m_doc ? m_doc->docLoader() : 0; }
+
+    DocumentImpl *doc() const { return m_doc; }
+    bool implicit() const { return m_implicit; }
+protected:
+    DocumentImpl *m_doc;
+    bool m_implicit;
+    TQ_UINT32 m_defaultNamespace;
+    CSSNamespace* m_namespaces;
+    DOMString m_charset;
+};
+
+// ----------------------------------------------------------------------------
+
+class StyleSheetListImpl : public tdehtml::Shared<StyleSheetListImpl>
+{
+public:
+    StyleSheetListImpl() {}
+    ~StyleSheetListImpl();
+
+    // the following two ignore implicit stylesheets
+    unsigned long length() const;
+    StyleSheetImpl *item ( unsigned long index );
+
+    void add(StyleSheetImpl* s);
+    void remove(StyleSheetImpl* s);
+
+    TQPtrList<StyleSheetImpl> styleSheets;
+};
+
+// ----------------------------------------------------------------------------
+
+class MediaListImpl : public StyleBaseImpl
+{
+public:
+    MediaListImpl()
+	: StyleBaseImpl( 0 ) {}
+    MediaListImpl( CSSStyleSheetImpl *parentSheet )
+        : StyleBaseImpl(parentSheet) {}
+    MediaListImpl( CSSStyleSheetImpl *parentSheet,
+                   const DOM::DOMString &media );
+    MediaListImpl( CSSRuleImpl *parentRule, const DOM::DOMString &media );
+
+    virtual bool isMediaList() const { return true; }
+
+    CSSStyleSheetImpl *parentStyleSheet() const;
+    CSSRuleImpl *parentRule() const;
+    unsigned long length() const { return m_lstMedia.count(); }
+    DOM::DOMString item ( unsigned long index ) const { return m_lstMedia[index]; }
+    void deleteMedium ( const DOM::DOMString &oldMedium );
+    void appendMedium ( const DOM::DOMString &newMedium ) { m_lstMedia.append(newMedium); }
+
+    DOM::DOMString mediaText() const;
+    void setMediaText(const DOM::DOMString &value);
+
+    /**
+     * Check if the list contains either the requested medium, or the
+     * catch-all "all" media type. Returns true when found, false otherwise.
+     * Since not specifying media types should be treated as "all" according
+     * to DOM specs, an empty list always returns true.
+     *
+     * _NOT_ part of the DOM!
+     */
+    bool contains( const DOM::DOMString &medium ) const;
+
+protected:
+    TQValueList<DOM::DOMString> m_lstMedia;
+};
+
+
+} // namespace
+
+#endif
+
diff --git a/tdehtml/css/css_valueimpl.cpp b/tdehtml/css/css_valueimpl.cpp
new file mode 100644
index 000000000..0da65c4b6
--- /dev/null
+++ b/tdehtml/css/css_valueimpl.cpp
@@ -0,0 +1,1073 @@
+/**
+ * This file is part of the DOM implementation for KDE.
+ *
+ * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org)
+ *           (C) 2004, 2005, 2006 Apple Computer, Inc.
+ *           (C) 2005 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.
+ */
+
+#include "dom/css_value.h"
+#include "dom/dom_exception.h"
+#include "dom/dom_string.h"
+
+#include "css/css_valueimpl.h"
+#include "css/css_ruleimpl.h"
+#include "css/css_stylesheetimpl.h"
+#include "css/cssparser.h"
+#include "css/cssproperties.h"
+#include "css/cssvalues.h"
+
+#include "xml/dom_stringimpl.h"
+#include "xml/dom_docimpl.h"
+
+#include "misc/loader.h"
+
+#include "rendering/font.h"
+#include "rendering/render_style.h"
+
+#include <kdebug.h>
+#include <tqregexp.h>
+#include <tqpaintdevice.h>
+#include <tqpaintdevicemetrics.h>
+
+// Hack for debugging purposes
+extern DOM::DOMString getPropertyName(unsigned short id);
+
+using tdehtml::FontDef;
+
+using namespace DOM;
+
+// Quotes the string if it needs quoting.
+static DOMString quoteStringIfNeeded(const DOMString &string)
+{
+    // FIXME: Also need to transform control characters into \ sequences.
+    TQString s = string.string();
+    s.replace('\\', "\\\\");
+    s.replace('\'', "\\'");
+    return '\'' + s + '\'';
+}
+
+
+CSSStyleDeclarationImpl::CSSStyleDeclarationImpl(CSSRuleImpl *parent)
+    : StyleBaseImpl(parent)
+{
+    m_lstValues = 0;
+    m_node = 0;
+}
+
+CSSStyleDeclarationImpl::CSSStyleDeclarationImpl(CSSRuleImpl *parent, TQPtrList<CSSProperty> *lstValues)
+    : StyleBaseImpl(parent)
+{
+    m_lstValues = lstValues;
+    m_node = 0;
+}
+
+CSSStyleDeclarationImpl&  CSSStyleDeclarationImpl::operator= (const CSSStyleDeclarationImpl& o)
+{
+    // don't attach it to the same node, just leave the current m_node value
+    delete m_lstValues;
+    m_lstValues = 0;
+    if (o.m_lstValues) {
+        m_lstValues = new TQPtrList<CSSProperty>;
+        m_lstValues->setAutoDelete( true );
+
+        TQPtrListIterator<CSSProperty> lstValuesIt(*o.m_lstValues);
+        for (lstValuesIt.toFirst(); lstValuesIt.current(); ++lstValuesIt)
+            m_lstValues->append(new CSSProperty(*lstValuesIt.current()));
+    }
+
+    return *this;
+}
+
+CSSStyleDeclarationImpl::~CSSStyleDeclarationImpl()
+{
+    delete m_lstValues;
+    // we don't use refcounting for m_node, to avoid cyclic references (see ElementImpl)
+}
+
+DOMString CSSStyleDeclarationImpl::getPropertyValue( int propertyID ) const
+{
+    if(!m_lstValues) return DOMString();
+    CSSValueImpl* value = getPropertyCSSValue( propertyID );
+    if ( value )
+        return value->cssText();
+
+    // Shorthand and 4-values properties
+    switch ( propertyID ) {
+    case CSS_PROP_BACKGROUND_POSITION:
+    {
+        // ## Is this correct? The code in cssparser.cpp is confusing
+        const int properties[2] = { CSS_PROP_BACKGROUND_POSITION_X,
+                                    CSS_PROP_BACKGROUND_POSITION_Y };
+        return getShortHandValue( properties, 2 );
+    }
+    case CSS_PROP_BACKGROUND:
+    {
+        const int properties[5] = { CSS_PROP_BACKGROUND_IMAGE, CSS_PROP_BACKGROUND_REPEAT,
+                                    CSS_PROP_BACKGROUND_ATTACHMENT, CSS_PROP_BACKGROUND_POSITION,
+                                    CSS_PROP_BACKGROUND_COLOR };
+        return getShortHandValue( properties, 5 );
+    }
+    case CSS_PROP_BORDER:
+    {
+        const int properties[3] = { CSS_PROP_BORDER_WIDTH, CSS_PROP_BORDER_STYLE,
+                                    CSS_PROP_BORDER_COLOR };
+        return getShortHandValue( properties, 3 );
+    }
+    case CSS_PROP_BORDER_TOP:
+    {
+        const int properties[3] = { CSS_PROP_BORDER_TOP_WIDTH, CSS_PROP_BORDER_TOP_STYLE,
+                                    CSS_PROP_BORDER_TOP_COLOR};
+        return getShortHandValue( properties, 3 );
+    }
+    case CSS_PROP_BORDER_RIGHT:
+    {
+        const int properties[3] = { CSS_PROP_BORDER_RIGHT_WIDTH, CSS_PROP_BORDER_RIGHT_STYLE,
+                                    CSS_PROP_BORDER_RIGHT_COLOR};
+        return getShortHandValue( properties, 3 );
+    }
+    case CSS_PROP_BORDER_BOTTOM:
+    {
+        const int properties[3] = { CSS_PROP_BORDER_BOTTOM_WIDTH, CSS_PROP_BORDER_BOTTOM_STYLE,
+                                    CSS_PROP_BORDER_BOTTOM_COLOR};
+        return getShortHandValue( properties, 3 );
+    }
+    case CSS_PROP_BORDER_LEFT:
+    {
+        const int properties[3] = { CSS_PROP_BORDER_LEFT_WIDTH, CSS_PROP_BORDER_LEFT_STYLE,
+                                    CSS_PROP_BORDER_LEFT_COLOR};
+        return getShortHandValue( properties, 3 );
+    }
+    case CSS_PROP_OUTLINE:
+    {
+        const int properties[3] = { CSS_PROP_OUTLINE_WIDTH, CSS_PROP_OUTLINE_STYLE,
+                                    CSS_PROP_OUTLINE_COLOR };
+        return getShortHandValue( properties, 3 );
+    }
+    case CSS_PROP_BORDER_COLOR:
+    {
+        const int properties[4] = { CSS_PROP_BORDER_TOP_COLOR, CSS_PROP_BORDER_RIGHT_COLOR,
+                                    CSS_PROP_BORDER_BOTTOM_COLOR, CSS_PROP_BORDER_LEFT_COLOR };
+        return get4Values( properties );
+    }
+    case CSS_PROP_BORDER_WIDTH:
+    {
+        const int properties[4] = { CSS_PROP_BORDER_TOP_WIDTH, CSS_PROP_BORDER_RIGHT_WIDTH,
+                                    CSS_PROP_BORDER_BOTTOM_WIDTH, CSS_PROP_BORDER_LEFT_WIDTH };
+        return get4Values( properties );
+    }
+    case CSS_PROP_BORDER_STYLE:
+    {
+        const int properties[4] = { CSS_PROP_BORDER_TOP_STYLE, CSS_PROP_BORDER_RIGHT_STYLE,
+                                    CSS_PROP_BORDER_BOTTOM_STYLE, CSS_PROP_BORDER_LEFT_STYLE };
+        return get4Values( properties );
+    }
+    case CSS_PROP_MARGIN:
+    {
+        const int properties[4] = { CSS_PROP_MARGIN_TOP, CSS_PROP_MARGIN_RIGHT,
+                                    CSS_PROP_MARGIN_BOTTOM, CSS_PROP_MARGIN_LEFT };
+        return get4Values( properties );
+    }
+    case CSS_PROP_PADDING:
+    {
+        const int properties[4] = { CSS_PROP_PADDING_TOP, CSS_PROP_PADDING_RIGHT,
+                                    CSS_PROP_PADDING_BOTTOM, CSS_PROP_PADDING_LEFT };
+        return get4Values( properties );
+    }
+    case CSS_PROP_LIST_STYLE:
+    {
+        const int properties[3] = { CSS_PROP_LIST_STYLE_TYPE, CSS_PROP_LIST_STYLE_POSITION,
+                                    CSS_PROP_LIST_STYLE_IMAGE };
+        return getShortHandValue( properties, 3 );
+    }
+    }
+    //kdDebug() << k_funcinfo << "property not found:" << propertyID << endl;
+    return DOMString();
+}
+
+DOMString CSSStyleDeclarationImpl::get4Values( const int* properties ) const
+{
+    DOMString res;
+    for ( int i = 0 ; i < 4 ; ++i ) {
+        CSSValueImpl* value = getPropertyCSSValue( properties[i] );
+        if ( !value ) { // apparently all 4 properties must be specified.
+            return DOMString();
+        }
+        if ( i > 0 )
+            res += " ";
+        res += value->cssText();
+    }
+    return res;
+}
+
+DOMString CSSStyleDeclarationImpl::getShortHandValue( const int* properties, int number ) const
+{
+    DOMString res;
+    for ( int i = 0 ; i < number ; ++i ) {
+        CSSValueImpl* value = getPropertyCSSValue( properties[i] );
+        if ( value ) { // TODO provide default value if !value
+            if ( !res.isNull() )
+                res += " ";
+            res += value->cssText();
+        }
+    }
+    return res;
+}
+
+ CSSValueImpl *CSSStyleDeclarationImpl::getPropertyCSSValue( int propertyID ) const
+{
+    if(!m_lstValues) return 0;
+
+    TQPtrListIterator<CSSProperty> lstValuesIt(*m_lstValues);
+    CSSProperty *current;
+    for ( lstValuesIt.toLast(); (current = lstValuesIt.current()); --lstValuesIt )
+        if (current->m_id == propertyID && !current->nonCSSHint)
+            return current->value();
+    return 0;
+}
+
+DOMString CSSStyleDeclarationImpl::removeProperty( int propertyID, bool NonCSSHint )
+{
+    if(!m_lstValues) return DOMString();
+    DOMString value;
+
+    TQPtrListIterator<CSSProperty> lstValuesIt(*m_lstValues);
+     CSSProperty *current;
+     for ( lstValuesIt.toLast(); (current = lstValuesIt.current()); --lstValuesIt )  {
+         if (current->m_id == propertyID && NonCSSHint == current->nonCSSHint) {
+             value = current->value()->cssText();
+             m_lstValues->removeRef(current);
+             setChanged();
+	     break;
+        }
+     }
+
+    return value;
+}
+
+void CSSStyleDeclarationImpl::setChanged()
+{
+    if (m_node) {
+        m_node->setChanged();
+        return;
+    }
+
+    // ### quick&dirty hack for KDE 3.0... make this MUCH better! (Dirk)
+    for (StyleBaseImpl* stylesheet = this; stylesheet; stylesheet = stylesheet->parent())
+        if (stylesheet->isCSSStyleSheet()) {
+            static_cast<CSSStyleSheetImpl*>(stylesheet)->doc()->updateStyleSelector();
+            break;
+        }
+}
+
+void CSSStyleDeclarationImpl::removeCSSHints()
+{
+    if (!m_lstValues)
+	return;
+
+    for (int i = (int)m_lstValues->count()-1; i >= 0; i--) {
+	if (!m_lstValues->at(i)->nonCSSHint)
+	    m_lstValues->remove(i);
+    }
+}
+
+bool CSSStyleDeclarationImpl::getPropertyPriority( int propertyID ) const
+{
+    if ( m_lstValues) {
+	TQPtrListIterator<CSSProperty> lstValuesIt(*m_lstValues);
+	CSSProperty *current;
+	for ( lstValuesIt.toFirst(); (current = lstValuesIt.current()); ++lstValuesIt ) {
+	    if( propertyID == current->m_id )
+		return current->m_important;
+	}
+    }
+    return false;
+}
+
+bool CSSStyleDeclarationImpl::setProperty(int id, const DOMString &value, bool important, bool nonCSSHint)
+{
+    if(!m_lstValues) {
+	m_lstValues = new TQPtrList<CSSProperty>;
+	m_lstValues->setAutoDelete(true);
+    }
+
+    CSSParser parser( strictParsing );
+    bool success = parser.parseValue( this, id, value, important, nonCSSHint );
+    if(!success)
+	kdDebug( 6080 ) << "CSSStyleDeclarationImpl::setProperty invalid property: [" << getPropertyName(id).string()
+			<< "] value: [" << value.string() << "]"<< endl;
+    else
+        setChanged();
+    return success;
+}
+
+void CSSStyleDeclarationImpl::setProperty(int id, int value, bool important, bool nonCSSHint)
+{
+    if(!m_lstValues) {
+	m_lstValues = new TQPtrList<CSSProperty>;
+	m_lstValues->setAutoDelete(true);
+    }
+    removeProperty(id, nonCSSHint );
+
+    CSSValueImpl * cssValue = new CSSPrimitiveValueImpl(value);
+    setParsedValue(id, cssValue, important, nonCSSHint, m_lstValues);
+    setChanged();
+}
+
+void CSSStyleDeclarationImpl::setLengthProperty(int id, const DOM::DOMString &value, bool important, bool nonCSSHint, bool _multiLength )
+{
+    bool parseMode = strictParsing;
+    strictParsing = false;
+    multiLength = _multiLength;
+    setProperty( id, value, important, nonCSSHint);
+    strictParsing = parseMode;
+    multiLength = false;
+}
+
+void CSSStyleDeclarationImpl::setProperty ( const DOMString &propertyString)
+{
+    if(!m_lstValues) {
+	m_lstValues = new TQPtrList<CSSProperty>;
+	m_lstValues->setAutoDelete( true );
+    }
+
+    CSSParser parser( strictParsing );
+    parser.parseDeclaration( this, propertyString, false );
+    setChanged();
+}
+
+unsigned long CSSStyleDeclarationImpl::length() const
+{
+    return m_lstValues ? m_lstValues->count() : 0;
+}
+
+DOMString CSSStyleDeclarationImpl::item( unsigned long index ) const
+{
+    if(m_lstValues && index < m_lstValues->count() && m_lstValues->at(index))
+	return getPropertyName(m_lstValues->at(index)->m_id);
+    return DOMString();
+}
+
+CSSRuleImpl *CSSStyleDeclarationImpl::parentRule() const
+{
+    return (m_parent && m_parent->isRule() ) ?
+	static_cast<CSSRuleImpl *>(m_parent) : 0;
+}
+
+DOM::DOMString CSSStyleDeclarationImpl::cssText() const
+{
+    DOMString result;
+
+    if ( m_lstValues) {
+	TQPtrListIterator<CSSProperty> lstValuesIt(*m_lstValues);
+	CSSProperty *current;
+	for ( lstValuesIt.toFirst(); (current = lstValuesIt.current()); ++lstValuesIt ) {
+	    result += current->cssText();
+	}
+    }
+
+    return result;
+}
+
+void CSSStyleDeclarationImpl::setCssText(DOM::DOMString text)
+{
+    if (m_lstValues) {
+	m_lstValues->clear();
+    } else {
+	m_lstValues = new TQPtrList<CSSProperty>;
+	m_lstValues->setAutoDelete( true );
+    }
+
+    CSSParser parser( strictParsing );
+    parser.parseDeclaration( this, text, false );
+    setChanged();
+}
+
+bool CSSStyleDeclarationImpl::parseString( const DOMString &/*string*/, bool )
+{
+    kdDebug() << "WARNING: CSSStyleDeclarationImpl::parseString, unimplemented, was called" << endl;
+    return false;
+    // ###
+}
+
+
+// --------------------------------------------------------------------------------------
+
+unsigned short CSSInheritedValueImpl::cssValueType() const
+{
+    return CSSValue::CSS_INHERIT;
+}
+
+DOM::DOMString CSSInheritedValueImpl::cssText() const
+{
+    return DOMString("inherit");
+}
+
+unsigned short CSSInitialValueImpl::cssValueType() const
+{
+    return CSSValue::CSS_INITIAL;
+}
+
+DOM::DOMString CSSInitialValueImpl::cssText() const
+{
+    return DOMString("initial");
+}
+
+// ----------------------------------------------------------------------------------------
+
+CSSValueListImpl::~CSSValueListImpl()
+{
+    CSSValueImpl *val = m_values.first();
+    while( val ) {
+	val->deref();
+	val = m_values.next();
+    }
+}
+
+unsigned short CSSValueListImpl::cssValueType() const
+{
+    return CSSValue::CSS_VALUE_LIST;
+}
+
+void CSSValueListImpl::append(CSSValueImpl *val)
+{
+    m_values.append(val);
+    val->ref();
+}
+
+DOM::DOMString CSSValueListImpl::cssText() const
+{
+    DOMString result = "";
+
+    for (TQPtrListIterator<CSSValueImpl> iterator(m_values); iterator.current(); ++iterator) {
+	result += iterator.current()->cssText();
+    }
+
+    return result;
+}
+
+// -------------------------------------------------------------------------------------
+
+CSSPrimitiveValueImpl::CSSPrimitiveValueImpl()
+    : CSSValueImpl()
+{
+    m_type = 0;
+}
+
+CSSPrimitiveValueImpl::CSSPrimitiveValueImpl(int ident)
+    : CSSValueImpl()
+{
+    m_value.ident = ident;
+    m_type = CSSPrimitiveValue::CSS_IDENT;
+}
+
+CSSPrimitiveValueImpl::CSSPrimitiveValueImpl(double num, CSSPrimitiveValue::UnitTypes type)
+{
+    m_value.num = num;
+    m_type = type;
+}
+
+CSSPrimitiveValueImpl::CSSPrimitiveValueImpl(const DOMString &str, CSSPrimitiveValue::UnitTypes type)
+{
+    m_value.string = str.implementation();
+    if(m_value.string) m_value.string->ref();
+    m_type = type;
+}
+
+CSSPrimitiveValueImpl::CSSPrimitiveValueImpl(CounterImpl *c)
+{
+    m_value.counter = c;
+    if (m_value.counter)
+	m_value.counter->ref();
+    m_type = CSSPrimitiveValue::CSS_COUNTER;
+}
+
+CSSPrimitiveValueImpl::CSSPrimitiveValueImpl( RectImpl *r)
+{
+    m_value.rect = r;
+    if (m_value.rect)
+	m_value.rect->ref();
+    m_type = CSSPrimitiveValue::CSS_RECT;
+}
+
+CSSPrimitiveValueImpl::CSSPrimitiveValueImpl(QRgb color)
+{
+    m_value.rgbcolor = color;
+    m_type = CSSPrimitiveValue::CSS_RGBCOLOR;
+}
+
+CSSPrimitiveValueImpl::CSSPrimitiveValueImpl(PairImpl *p)
+{
+    m_value.pair = p;
+    if (m_value.pair)
+	m_value.pair->ref();
+    m_type = CSSPrimitiveValue::CSS_PAIR;
+}
+
+
+CSSPrimitiveValueImpl::~CSSPrimitiveValueImpl()
+{
+    cleanup();
+}
+
+void CSSPrimitiveValueImpl::cleanup()
+{
+    switch(m_type) {
+    case CSSPrimitiveValue::CSS_STRING:
+    case CSSPrimitiveValue::CSS_URI:
+    case CSSPrimitiveValue::CSS_ATTR:
+	if(m_value.string) m_value.string->deref();
+        break;
+    case CSSPrimitiveValue::CSS_COUNTER:
+	m_value.counter->deref();
+        break;
+    case CSSPrimitiveValue::CSS_RECT:
+	m_value.rect->deref();
+        break;
+    case CSSPrimitiveValue::CSS_PAIR:
+        m_value.pair->deref();
+        break;
+    default:
+        break;
+    }
+
+    m_type = 0;
+}
+
+int CSSPrimitiveValueImpl::computeLength( tdehtml::RenderStyle *style, TQPaintDeviceMetrics *devMetrics )
+{
+    double result = computeLengthFloat( style, devMetrics );
+    // This conversion is imprecise, often resulting in values of, e.g., 44.99998.  We
+    // need to go ahead and round if we're really close to the next integer value.
+    int intResult = (int)(result + (result < 0 ? -0.01 : +0.01));
+    return intResult;
+}
+
+double CSSPrimitiveValueImpl::computeLengthFloat( tdehtml::RenderStyle *style, TQPaintDeviceMetrics *devMetrics )
+{
+    unsigned short type = primitiveType();
+
+    double dpiY = 72.; // fallback
+    if ( devMetrics )
+        dpiY = devMetrics->logicalDpiY();
+    if ( !tdehtml::printpainter && dpiY < 96 )
+        dpiY = 96.;
+
+    double factor = 1.;
+    switch(type)
+    {
+    case CSSPrimitiveValue::CSS_EMS:
+        factor = style->font().pixelSize();
+        break;
+    case CSSPrimitiveValue::CSS_EXS:
+	{
+        TQFontMetrics fm = style->fontMetrics();
+#ifdef APPLE_CHANGES
+        factor = fm.xHeight();
+#else
+        TQRect b = fm.boundingRect('x');
+        factor = b.height();
+#endif
+        break;
+	}
+    case CSSPrimitiveValue::CSS_PX:
+        break;
+    case CSSPrimitiveValue::CSS_CM:
+	factor = dpiY/2.54; //72dpi/(2.54 cm/in)
+        break;
+    case CSSPrimitiveValue::CSS_MM:
+	factor = dpiY/25.4;
+        break;
+    case CSSPrimitiveValue::CSS_IN:
+        factor = dpiY;
+        break;
+    case CSSPrimitiveValue::CSS_PT:
+        factor = dpiY/72.;
+        break;
+    case CSSPrimitiveValue::CSS_PC:
+        // 1 pc == 12 pt
+        factor = dpiY*12./72.;
+        break;
+    default:
+        return -1;
+    }
+
+    return floatValue(type)*factor;
+}
+
+void CSSPrimitiveValueImpl::setFloatValue( unsigned short unitType, double floatValue, int &exceptioncode )
+{
+    exceptioncode = 0;
+    cleanup();
+    // ### check if property supports this type
+    if(m_type > CSSPrimitiveValue::CSS_DIMENSION) {
+	exceptioncode = CSSException::SYNTAX_ERR + CSSException::_EXCEPTION_OFFSET;
+	return;
+    }
+    //if(m_type > CSSPrimitiveValue::CSS_DIMENSION) throw DOMException(DOMException::INVALID_ACCESS_ERR);
+    m_value.num = floatValue;
+    m_type = unitType;
+}
+
+void CSSPrimitiveValueImpl::setStringValue( unsigned short stringType, const DOMString &stringValue, int &exceptioncode )
+{
+    exceptioncode = 0;
+    cleanup();
+    //if(m_type < CSSPrimitiveValue::CSS_STRING) throw DOMException(DOMException::INVALID_ACCESS_ERR);
+    //if(m_type > CSSPrimitiveValue::CSS_ATTR) throw DOMException(DOMException::INVALID_ACCESS_ERR);
+    if(m_type < CSSPrimitiveValue::CSS_STRING || m_type > CSSPrimitiveValue::CSS_ATTR) {
+	exceptioncode = CSSException::SYNTAX_ERR + CSSException::_EXCEPTION_OFFSET;
+	return;
+    }
+    if(stringType != CSSPrimitiveValue::CSS_IDENT)
+    {
+	m_value.string = stringValue.implementation();
+	m_value.string->ref();
+	m_type = stringType;
+    }
+    // ### parse ident
+}
+
+unsigned short CSSPrimitiveValueImpl::cssValueType() const
+{
+    return CSSValue::CSS_PRIMITIVE_VALUE;
+}
+
+bool CSSPrimitiveValueImpl::parseString( const DOMString &/*string*/, bool )
+{
+    // ###
+    kdDebug() << "WARNING: CSSPrimitiveValueImpl::parseString, unimplemented, was called" << endl;
+    return false;
+}
+
+int CSSPrimitiveValueImpl::getIdent()
+{
+    if(m_type != CSSPrimitiveValue::CSS_IDENT) return 0;
+    return m_value.ident;
+}
+
+DOM::DOMString CSSPrimitiveValueImpl::cssText() const
+{
+    // ### return the original value instead of a generated one (e.g. color
+    // name if it was specified) - check what spec says about this
+    DOMString text;
+    switch ( m_type ) {
+	case CSSPrimitiveValue::CSS_UNKNOWN:
+	    // ###
+	    break;
+	case CSSPrimitiveValue::CSS_NUMBER:
+	    text = DOMString(TQString::number( (int)m_value.num ));
+	    break;
+	case CSSPrimitiveValue::CSS_PERCENTAGE:
+	    text = DOMString(TQString::number( m_value.num ) + "%");
+	    break;
+	case CSSPrimitiveValue::CSS_EMS:
+	    text = DOMString(TQString::number( m_value.num ) + "em");
+	    break;
+	case CSSPrimitiveValue::CSS_EXS:
+	    text = DOMString(TQString::number( m_value.num ) + "ex");
+	    break;
+	case CSSPrimitiveValue::CSS_PX:
+	    text = DOMString(TQString::number( m_value.num ) + "px");
+	    break;
+	case CSSPrimitiveValue::CSS_CM:
+	    text = DOMString(TQString::number( m_value.num ) + "cm");
+	    break;
+	case CSSPrimitiveValue::CSS_MM:
+	    text = DOMString(TQString::number( m_value.num ) + "mm");
+	    break;
+	case CSSPrimitiveValue::CSS_IN:
+	    text = DOMString(TQString::number( m_value.num ) + "in");
+	    break;
+	case CSSPrimitiveValue::CSS_PT:
+	    text = DOMString(TQString::number( m_value.num ) + "pt");
+	    break;
+	case CSSPrimitiveValue::CSS_PC:
+	    text = DOMString(TQString::number( m_value.num ) + "pc");
+	    break;
+	case CSSPrimitiveValue::CSS_DEG:
+	    text = DOMString(TQString::number( m_value.num ) + "deg");
+	    break;
+	case CSSPrimitiveValue::CSS_RAD:
+	    text = DOMString(TQString::number( m_value.num ) + "rad");
+	    break;
+	case CSSPrimitiveValue::CSS_GRAD:
+	    text = DOMString(TQString::number( m_value.num ) + "grad");
+	    break;
+	case CSSPrimitiveValue::CSS_MS:
+	    text = DOMString(TQString::number( m_value.num ) + "ms");
+	    break;
+	case CSSPrimitiveValue::CSS_S:
+	    text = DOMString(TQString::number( m_value.num ) + "s");
+	    break;
+	case CSSPrimitiveValue::CSS_HZ:
+	    text = DOMString(TQString::number( m_value.num ) + "hz");
+	    break;
+	case CSSPrimitiveValue::CSS_KHZ:
+	    text = DOMString(TQString::number( m_value.num ) + "khz");
+	    break;
+	case CSSPrimitiveValue::CSS_DIMENSION:
+	    // ###
+	    break;
+	case CSSPrimitiveValue::CSS_STRING:
+	    text = quoteStringIfNeeded(m_value.string);
+	    break;
+	case CSSPrimitiveValue::CSS_URI:
+            text  = "url(";
+	    text += DOMString( m_value.string );
+            text += ")";
+	    break;
+	case CSSPrimitiveValue::CSS_IDENT:
+	    text = getValueName(m_value.ident);
+	    break;
+	case CSSPrimitiveValue::CSS_ATTR:
+            text = "attr(";
+            text += DOMString( m_value.string );
+            text += ")";
+	    break;
+	case CSSPrimitiveValue::CSS_COUNTER:
+            text = "counter(";
+            text += m_value.counter->m_identifier;
+            text += ")";
+            // ### add list-style and separator
+	    break;
+	case CSSPrimitiveValue::CSS_RECT:
+        {
+            RectImpl* rectVal = getRectValue();
+            text = "rect(";
+            text += rectVal->top()->cssText() + " ";
+            text += rectVal->right()->cssText() + " ";
+            text += rectVal->bottom()->cssText() + " ";
+            text += rectVal->left()->cssText() + ")";
+            break;
+        }
+	case CSSPrimitiveValue::CSS_RGBCOLOR:
+	    if (tqAlpha(m_value.rgbcolor) != 0xFF) {
+		if (m_value.rgbcolor == tdehtml::transparentColor)
+		    text = "transparent";
+		else
+		    text = "rgba(" + TQString::number(tqRed  (m_value.rgbcolor)) + "," 
+				   + TQString::number(tqBlue (m_value.rgbcolor)) + "," 
+				   + TQString::number(tqGreen(m_value.rgbcolor)) + "," 
+				   + TQString::number(tqAlpha(m_value.rgbcolor)/255.0) + ")";
+	    } else {
+		text = TQString(TQColor(m_value.rgbcolor).name());
+	    }
+	    break;
+        case CSSPrimitiveValue::CSS_PAIR:
+            text = m_value.pair->first()->cssText();
+            text += " ";
+            text += m_value.pair->second()->cssText();
+            break;
+	default:
+	    break;
+    }
+    return text;
+}
+
+// -----------------------------------------------------------------
+
+RectImpl::RectImpl()
+{
+    m_top = 0;
+    m_right = 0;
+    m_bottom = 0;
+    m_left = 0;
+}
+
+RectImpl::~RectImpl()
+{
+    if (m_top) m_top->deref();
+    if (m_right) m_right->deref();
+    if (m_bottom) m_bottom->deref();
+    if (m_left) m_left->deref();
+}
+
+void RectImpl::setTop( CSSPrimitiveValueImpl *top )
+{
+    if( top ) top->ref();
+    if ( m_top ) m_top->deref();
+    m_top = top;
+}
+
+void RectImpl::setRight( CSSPrimitiveValueImpl *right )
+{
+    if( right ) right->ref();
+    if ( m_right ) m_right->deref();
+    m_right = right;
+}
+
+void RectImpl::setBottom( CSSPrimitiveValueImpl *bottom )
+{
+    if( bottom ) bottom->ref();
+    if ( m_bottom ) m_bottom->deref();
+    m_bottom = bottom;
+}
+
+void RectImpl::setLeft( CSSPrimitiveValueImpl *left )
+{
+    if( left ) left->ref();
+    if ( m_left ) m_left->deref();
+    m_left = left;
+}
+
+// -----------------------------------------------------------------
+
+PairImpl::~PairImpl()
+{
+    if (m_first) m_first->deref(); if (m_second) m_second->deref();
+}
+
+void PairImpl::setFirst(CSSPrimitiveValueImpl* first)
+{
+    if (first == m_first) return;
+    if (m_first) m_first->deref();
+    m_first = first;
+    if (m_first) m_first->ref();
+}
+
+void PairImpl::setSecond(CSSPrimitiveValueImpl* second)
+{
+    if (second == m_second) return;
+    if (m_second) m_second->deref();
+    m_second = second;
+    if (m_second) m_second->ref();
+}
+
+// -----------------------------------------------------------------
+
+CSSImageValueImpl::CSSImageValueImpl(const DOMString &url, const StyleBaseImpl* style)
+    : CSSPrimitiveValueImpl(url, CSSPrimitiveValue::CSS_URI)
+{
+    tdehtml::DocLoader *docLoader = 0;
+    const StyleBaseImpl *root = style;
+    while (root->parent())
+	root = root->parent();
+    if (root->isCSSStyleSheet())
+	docLoader = static_cast<const CSSStyleSheetImpl*>(root)->docLoader();
+
+    m_image = docLoader->requestImage(url);
+    if(m_image) m_image->ref(this);
+}
+
+CSSImageValueImpl::CSSImageValueImpl()
+    : CSSPrimitiveValueImpl(CSS_VAL_NONE)
+{
+    m_image = 0;
+}
+
+CSSImageValueImpl::~CSSImageValueImpl()
+{
+    if(m_image) m_image->deref(this);
+}
+
+// ------------------------------------------------------------------------
+
+FontFamilyValueImpl::FontFamilyValueImpl( const TQString &string)
+: CSSPrimitiveValueImpl( DOMString(string), CSSPrimitiveValue::CSS_STRING)
+{
+    static const TQRegExp parenReg(" \\(.*\\)$");
+    static const TQRegExp braceReg(" \\[.*\\]$");
+
+    parsedFontName = string;
+    // a language tag is often added in braces at the end. Remove it.
+    parsedFontName.replace(parenReg, TQString());
+    // remove [Xft] qualifiers
+    parsedFontName.replace(braceReg, TQString());
+
+#ifndef APPLE_CHANGES
+    const TQString &available = KHTMLSettings::availableFamilies();
+
+    parsedFontName = parsedFontName.lower();
+    // kdDebug(0) << "searching for face '" << parsedFontName << "'" << endl;
+
+    int pos = available.find( ',' + parsedFontName + ',', 0, false );
+    if ( pos == -1 ) {
+        // many pages add extra MSs to make sure it's windows only ;(
+        if ( parsedFontName.startsWith( "ms " ) )
+            parsedFontName = parsedFontName.mid( 3 );
+        if ( parsedFontName.endsWith( " ms" ) )
+            parsedFontName.truncate( parsedFontName.length() - 3 );
+        pos = available.find( ",ms " + parsedFontName + ',', 0, false );
+        if ( pos == -1 )
+            pos = available.find( ',' + parsedFontName + " ms,", 0, false );
+    }
+
+    if ( pos != -1 ) {
+       ++pos;
+       int p = available.find(',', pos);
+       assert( p != -1 ); // available is supposed to start and end with ,
+       parsedFontName = available.mid( pos, p - pos);
+       // kdDebug(0) << "going for '" << parsedFontName << "'" << endl;
+    } else
+        parsedFontName = TQString::null;
+
+#endif // !APPLE_CHANGES
+}
+
+FontValueImpl::FontValueImpl()
+    : style(0), variant(0), weight(0), size(0), lineHeight(0), family(0)
+{
+}
+
+FontValueImpl::~FontValueImpl()
+{
+    delete style;
+    delete variant;
+    delete weight;
+    delete size;
+    delete lineHeight;
+    delete family;
+}
+
+DOMString FontValueImpl::cssText() const
+{
+    // font variant weight size / line-height family
+
+    DOMString result("");
+
+    if (style) {
+	result += style->cssText();
+    }
+    if (variant) {
+	if (result.length() > 0) {
+	    result += " ";
+	}
+	result += variant->cssText();
+    }
+    if (weight) {
+	if (result.length() > 0) {
+	    result += " ";
+	}
+	result += weight->cssText();
+    }
+    if (size) {
+	if (result.length() > 0) {
+	    result += " ";
+	}
+	result += size->cssText();
+    }
+    if (lineHeight) {
+	if (!size) {
+	    result += " ";
+	}
+	result += "/";
+	result += lineHeight->cssText();
+    }
+    if (family) {
+	if (result.length() > 0) {
+	    result += " ";
+	}
+	result += family->cssText();
+    }
+
+    return result;
+}
+
+QuotesValueImpl::QuotesValueImpl()
+    : levels(0)
+{
+}
+
+DOMString QuotesValueImpl::cssText() const
+{
+    return "\"" + data.join("\" \"") + "\"";
+}
+
+void QuotesValueImpl::addLevel(const TQString& open, const TQString& close)
+{
+    data.append(open);
+    data.append(close);
+    levels++;
+}
+
+TQString QuotesValueImpl::openQuote(int level) const
+{
+    if (levels == 0) return "";
+    level--; // increments are calculated before openQuote is called
+//     kdDebug( 6080 ) << "Open quote level:" << level << endl;
+    if (level < 0) level = 0;
+    else
+    if (level >= (int) levels) level = (int) (levels-1);
+    return data[level*2];
+}
+
+TQString QuotesValueImpl::closeQuote(int level) const
+{
+    if (levels == 0) return "";
+//     kdDebug( 6080 ) << "Close quote level:" << level << endl;
+    if (level < 0) level = 0;
+    else
+    if (level >= (int) levels) level = (int) (levels-1);
+    return data[level*2+1];
+}
+
+// Used for text-shadow and box-shadow
+ShadowValueImpl::ShadowValueImpl(CSSPrimitiveValueImpl* _x, CSSPrimitiveValueImpl* _y,
+                                 CSSPrimitiveValueImpl* _blur, CSSPrimitiveValueImpl* _color)
+    :x(_x), y(_y), blur(_blur), color(_color)
+{}
+
+ShadowValueImpl::~ShadowValueImpl()
+{
+    delete x;
+    delete y;
+    delete blur;
+    delete color;
+}
+
+DOMString ShadowValueImpl::cssText() const
+{
+    DOMString text("");
+    if (color) {
+        text += color->cssText();
+    }
+    if (x) {
+        if (text.length() > 0) {
+            text += " ";
+        }
+        text += x->cssText();
+    }
+    if (y) {
+        if (text.length() > 0) {
+            text += " ";
+        }
+        text += y->cssText();
+    }
+    if (blur) {
+        if (text.length() > 0) {
+            text += " ";
+        }
+        text += blur->cssText();
+    }
+
+    return text;
+}
+
+DOMString CounterActImpl::cssText() const
+{
+    DOMString text(m_counter);
+    text += DOMString(TQString::number(m_value));
+
+    return text;
+}
+
+DOMString CSSProperty::cssText() const
+{
+    return getPropertyName(m_id) + DOMString(": ") + m_value->cssText() + (m_important ? DOMString(" !important") : DOMString()) + DOMString("; ");
+}
diff --git a/tdehtml/css/css_valueimpl.h b/tdehtml/css/css_valueimpl.h
new file mode 100644
index 000000000..9a6203c86
--- /dev/null
+++ b/tdehtml/css/css_valueimpl.h
@@ -0,0 +1,461 @@
+/*
+ * This file is part of the DOM implementation for KDE.
+ *
+ * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org)
+ *           (C) 2004, 2005, 2006 Apple Computer, Inc.
+ *           (C) 2005 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.
+ *
+ */
+#ifndef _CSS_css_valueimpl_h_
+#define _CSS_css_valueimpl_h_
+
+#include "dom/css_value.h"
+#include "dom/dom_string.h"
+#include "css/css_base.h"
+#include "misc/loader_client.h"
+#include "misc/shared.h"
+
+#include <tqintdict.h>
+
+namespace tdehtml {
+    class RenderStyle;
+    class CachedImage;
+}
+
+
+namespace DOM {
+
+class CSSRuleImpl;
+class CSSValueImpl;
+class NodeImpl;
+class CounterImpl;
+class PairImpl;
+
+
+class CSSStyleDeclarationImpl : public StyleBaseImpl
+{
+public:
+    CSSStyleDeclarationImpl(CSSRuleImpl *parentRule);
+    CSSStyleDeclarationImpl(CSSRuleImpl *parentRule, TQPtrList<CSSProperty> *lstValues);
+    virtual ~CSSStyleDeclarationImpl();
+
+    CSSStyleDeclarationImpl& operator=( const CSSStyleDeclarationImpl&);
+
+    virtual unsigned long length() const;
+    CSSRuleImpl *parentRule() const;
+    virtual DOM::DOMString removeProperty( int propertyID, bool NonCSSHints = false );
+    virtual bool setProperty ( int propertyId, const DOM::DOMString &value, bool important = false, bool nonCSSHint = false);
+    virtual void setProperty ( int propertyId, int value, bool important = false, bool nonCSSHint = false);
+    // this treats integers as pixels!
+    // needed for conversion of html attributes
+    virtual void setLengthProperty(int id, const DOM::DOMString &value, bool important, bool nonCSSHint = true, bool multiLength = false);
+
+    // add a whole, unparsed property
+    virtual void setProperty ( const DOMString &propertyString);
+    virtual DOM::DOMString item ( unsigned long index ) const;
+
+    DOM::DOMString cssText() const;
+    void setCssText(DOM::DOMString str);
+
+    virtual bool isStyleDeclaration() const { return true; }
+    virtual bool parseString( const DOMString &string, bool = false );
+
+    virtual CSSValueImpl *getPropertyCSSValue( int propertyID ) const;
+    virtual DOMString getPropertyValue( int propertyID ) const;
+    virtual bool getPropertyPriority( int propertyID ) const;
+
+    TQPtrList<CSSProperty> *values() const { return m_lstValues; }
+    void setNode(NodeImpl *_node) { m_node = _node; }
+
+    void setChanged();
+
+    void removeCSSHints();
+
+protected:
+    DOMString getShortHandValue( const int* properties, int number ) const;
+    DOMString get4Values( const int* properties ) const;
+
+    TQPtrList<CSSProperty> *m_lstValues;
+    NodeImpl *m_node;
+
+private:
+    // currently not needed - make sure its not used
+    CSSStyleDeclarationImpl(const CSSStyleDeclarationImpl& o);
+};
+
+class CSSValueImpl : public StyleBaseImpl
+{
+public:
+    CSSValueImpl() : StyleBaseImpl() {}
+
+    virtual unsigned short cssValueType() const = 0;
+
+    virtual DOM::DOMString cssText() const = 0;
+
+    virtual bool isValue() const { return true; }
+    virtual bool isFontValue() const { return false; }
+};
+
+class CSSInheritedValueImpl : public CSSValueImpl
+{
+public:
+    CSSInheritedValueImpl() : CSSValueImpl() {}
+    virtual ~CSSInheritedValueImpl() {}
+
+    virtual unsigned short cssValueType() const;
+    virtual DOM::DOMString cssText() const;
+};
+
+class CSSInitialValueImpl : public CSSValueImpl
+{
+public:
+    virtual unsigned short cssValueType() const;
+    virtual DOM::DOMString cssText() const;
+};
+
+class CSSValueListImpl : public CSSValueImpl
+{
+public:
+    CSSValueListImpl() : CSSValueImpl() {}
+
+    virtual ~CSSValueListImpl();
+
+    unsigned long length() const { return m_values.count(); }
+    CSSValueImpl *item ( unsigned long index ) { return m_values.at(index); }
+
+    virtual bool isValueList() const { return true; }
+
+    virtual unsigned short cssValueType() const;
+
+    void append(CSSValueImpl *val);
+    virtual DOM::DOMString cssText() const;
+
+protected:
+    TQPtrList<CSSValueImpl> m_values;
+};
+
+
+class Counter;
+class RGBColor;
+class Rect;
+
+class CSSPrimitiveValueImpl : public CSSValueImpl
+{
+public:
+    CSSPrimitiveValueImpl();
+    CSSPrimitiveValueImpl(int ident);
+    CSSPrimitiveValueImpl(double num, CSSPrimitiveValue::UnitTypes type);
+    CSSPrimitiveValueImpl(const DOMString &str, CSSPrimitiveValue::UnitTypes type);
+    CSSPrimitiveValueImpl(CounterImpl *c);
+    CSSPrimitiveValueImpl( RectImpl *r);
+    CSSPrimitiveValueImpl(QRgb color);
+    CSSPrimitiveValueImpl(PairImpl *p);
+
+    virtual ~CSSPrimitiveValueImpl();
+
+    void cleanup();
+
+    unsigned short primitiveType() const { return m_type; }
+
+    /*
+     * computes a length in pixels out of the given CSSValue. Need the RenderStyle to get
+     * the fontinfo in case val is defined in em or ex.
+     *
+     * The metrics have to be a bit different for screen and printer output.
+     * For screen output we assume 1 inch == 72 px, for printer we assume 300 dpi
+     *
+     * this is screen/printer dependent, so we probably need a config option for this,
+     * and some tool to calibrate.
+     */
+    int computeLength( tdehtml::RenderStyle *style, TQPaintDeviceMetrics *devMetrics );
+
+    double computeLengthFloat( tdehtml::RenderStyle *style, TQPaintDeviceMetrics *devMetrics );
+
+    // use with care!!!
+    void setPrimitiveType(unsigned short type) { m_type = type; }
+    void setFloatValue ( unsigned short unitType, double floatValue, int &exceptioncode );
+    double floatValue ( unsigned short/* unitType */) const { return m_value.num; }
+
+    void setStringValue ( unsigned short stringType, const DOM::DOMString &stringValue, int &exceptioncode );
+    DOM::DOMStringImpl *getStringValue () const {
+	return ( ( m_type < CSSPrimitiveValue::CSS_STRING ||
+		   m_type > CSSPrimitiveValue::CSS_ATTR ||
+		   m_type == CSSPrimitiveValue::CSS_IDENT ) ? // fix IDENT
+		 0 : m_value.string );
+    }
+    CounterImpl *getCounterValue () const {
+        return ( m_type != CSSPrimitiveValue::CSS_COUNTER ? 0 : m_value.counter );
+    }
+
+    RectImpl *getRectValue () const {
+	return ( m_type != CSSPrimitiveValue::CSS_RECT ? 0 : m_value.rect );
+    }
+
+    QRgb getRGBColorValue () const {
+	return ( m_type != CSSPrimitiveValue::CSS_RGBCOLOR ? 0 : m_value.rgbcolor );
+    }
+
+    PairImpl* getPairValue() const {
+        return (m_type != CSSPrimitiveValue::CSS_PAIR ? 0 : m_value.pair);
+    }
+
+    virtual bool isPrimitiveValue() const { return true; }
+    virtual unsigned short cssValueType() const;
+
+    int getIdent();
+
+    virtual bool parseString( const DOMString &string, bool = false);
+    virtual DOM::DOMString cssText() const;
+
+    virtual bool isQuirkValue() const { return false; }
+
+protected:
+    int m_type;
+    union {
+	int ident;
+	double num;
+	DOM::DOMStringImpl *string;
+	CounterImpl *counter;
+	RectImpl *rect;
+        QRgb rgbcolor;
+        PairImpl* pair;
+    } m_value;
+};
+
+// This value is used to handle quirky margins in reflow roots (body, td, and th) like WinIE.
+// The basic idea is that a stylesheet can use the value __qem (for quirky em) instead of em
+// in a stylesheet.  When the quirky value is used, if you're in quirks mode, the margin will
+// collapse away inside a table cell.
+class CSSQuirkPrimitiveValueImpl : public CSSPrimitiveValueImpl
+{
+public:
+    CSSQuirkPrimitiveValueImpl(double num, CSSPrimitiveValue::UnitTypes type)
+      :CSSPrimitiveValueImpl(num, type) {}
+
+    virtual ~CSSQuirkPrimitiveValueImpl() {}
+
+    virtual bool isQuirkValue() const { return true; }
+};
+
+class CounterImpl : public tdehtml::Shared<CounterImpl> {
+public:
+    CounterImpl() : m_listStyle(0) { }
+    DOMString identifier() const { return m_identifier; }
+    unsigned int listStyle() const { return m_listStyle; }
+    DOMString separator() const { return m_separator; }
+
+    DOMString m_identifier;
+    unsigned int m_listStyle;
+    DOMString m_separator;
+};
+
+class RectImpl : public tdehtml::Shared<RectImpl> {
+public:
+    RectImpl();
+    ~RectImpl();
+
+    CSSPrimitiveValueImpl *top() const { return m_top; }
+    CSSPrimitiveValueImpl *right() const { return m_right; }
+    CSSPrimitiveValueImpl *bottom() const { return m_bottom; }
+    CSSPrimitiveValueImpl *left() const { return m_left; }
+
+    void setTop( CSSPrimitiveValueImpl *top );
+    void setRight( CSSPrimitiveValueImpl *right );
+    void setBottom( CSSPrimitiveValueImpl *bottom );
+    void setLeft( CSSPrimitiveValueImpl *left );
+protected:
+    CSSPrimitiveValueImpl *m_top;
+    CSSPrimitiveValueImpl *m_right;
+    CSSPrimitiveValueImpl *m_bottom;
+    CSSPrimitiveValueImpl *m_left;
+};
+
+// A primitive value representing a pair.  This is useful for properties like border-radius, background-size/position,
+// and border-spacing (all of which are space-separated sets of two values).  At the moment we are only using it for
+// border-radius and background-size, but (FIXME) border-spacing and background-position could be converted over to use
+// it (eliminating some extra -webkit- internal properties).
+class PairImpl : public tdehtml::Shared<PairImpl> {
+public:
+    PairImpl() : m_first(0), m_second(0) { }
+    PairImpl(CSSPrimitiveValueImpl* first, CSSPrimitiveValueImpl* second)
+        : m_first(first), m_second(second) { if (first) first->ref(); if (second) second->ref(); }
+    virtual ~PairImpl();
+
+    CSSPrimitiveValueImpl* first() const { return m_first; }
+    CSSPrimitiveValueImpl* second() const { return m_second; }
+
+    void setFirst(CSSPrimitiveValueImpl* first);
+    void setSecond(CSSPrimitiveValueImpl* second);
+
+protected:
+    CSSPrimitiveValueImpl* m_first;
+    CSSPrimitiveValueImpl* m_second;
+};
+
+
+class CSSImageValueImpl : public CSSPrimitiveValueImpl, public tdehtml::CachedObjectClient
+{
+public:
+    CSSImageValueImpl(const DOMString &url, const StyleBaseImpl *style);
+    CSSImageValueImpl();
+    virtual ~CSSImageValueImpl();
+
+    tdehtml::CachedImage *image() { return m_image; }
+protected:
+    tdehtml::CachedImage *m_image;
+};
+
+class FontFamilyValueImpl : public CSSPrimitiveValueImpl
+{
+public:
+    FontFamilyValueImpl( const TQString &string);
+    const TQString &fontName() const { return parsedFontName; }
+    int genericFamilyType() const { return _genericFamilyType; }
+protected:
+    TQString parsedFontName;
+private:
+    int _genericFamilyType;
+};
+
+class FontValueImpl : public CSSValueImpl
+{
+public:
+    FontValueImpl();
+    virtual ~FontValueImpl();
+
+    virtual unsigned short cssValueType() const { return CSSValue::CSS_CUSTOM; }
+
+    virtual DOM::DOMString cssText() const;
+
+    virtual bool isFontValue() const { return true; }
+
+    CSSPrimitiveValueImpl *style;
+    CSSPrimitiveValueImpl *variant;
+    CSSPrimitiveValueImpl *weight;
+    CSSPrimitiveValueImpl *size;
+    CSSPrimitiveValueImpl *lineHeight;
+    CSSValueListImpl *family;
+};
+
+// Used for quotes
+class QuotesValueImpl : public CSSValueImpl
+{
+public:
+    QuotesValueImpl();
+//    virtual ~QuotesValueImpl();
+
+    virtual unsigned short cssValueType() const { return CSSValue::CSS_CUSTOM; }
+    virtual DOM::DOMString cssText() const;
+
+    void addLevel(const TQString& open, const TQString& close);
+    TQString openQuote(int level) const;
+    TQString closeQuote(int level) const;
+
+    unsigned int levels;
+    TQStringList data;
+};
+
+// Used for text-shadow and box-shadow
+class ShadowValueImpl : public CSSValueImpl
+{
+public:
+    ShadowValueImpl(CSSPrimitiveValueImpl* _x, CSSPrimitiveValueImpl* _y,
+                    CSSPrimitiveValueImpl* _blur, CSSPrimitiveValueImpl* _color);
+    virtual ~ShadowValueImpl();
+
+    virtual unsigned short cssValueType() const { return CSSValue::CSS_CUSTOM; }
+
+    virtual DOM::DOMString cssText() const;
+
+    CSSPrimitiveValueImpl* x;
+    CSSPrimitiveValueImpl* y;
+    CSSPrimitiveValueImpl* blur;
+    CSSPrimitiveValueImpl* color;
+};
+
+// Used for counter-reset and counter-increment
+class CounterActImpl : public CSSValueImpl {
+    public:
+        CounterActImpl(const DOMString &c, short v) : m_counter(c), m_value(v) { }
+        virtual ~CounterActImpl() {};
+
+        virtual unsigned short cssValueType() const { return CSSValue::CSS_CUSTOM; }
+        virtual DOM::DOMString cssText() const;
+
+        const DOMString& counter() const { return m_counter; }
+        short value() const { return m_value; }
+        void setValue( const short v ) { m_value = v; }
+
+        DOM::DOMString m_counter;
+        short m_value;
+};
+
+
+// ------------------------------------------------------------------------------
+
+// another helper class
+class CSSProperty
+{
+public:
+    CSSProperty()
+    {
+	m_id = -1;
+	m_important = false;
+	nonCSSHint = false;
+        m_value = 0;
+    }
+    CSSProperty(const CSSProperty& o)
+    {
+        m_id = o.m_id;
+        m_important = o.m_important;
+        nonCSSHint = o.nonCSSHint;
+        m_value = o.m_value;
+        if (m_value) m_value->ref();
+    }
+    ~CSSProperty() {
+	if(m_value) m_value->deref();
+    }
+
+    void setValue(CSSValueImpl *val) {
+	if ( val != m_value ) {
+	    if(m_value) m_value->deref();
+	    m_value = val;
+	    if(m_value) m_value->ref();
+	}
+    }
+
+    int id() const { return m_id; }
+
+    bool isImportant() const { return m_important; }
+
+    CSSValueImpl *value() const { return m_value; }
+
+    DOM::DOMString cssText() const;
+
+    // make sure the following fits in 4 bytes.
+    signed int  m_id   : 29;
+    bool m_important   : 1;
+    bool nonCSSHint    : 1;
+protected:
+    CSSValueImpl *m_value;
+};
+
+
+} // namespace
+
+#endif
diff --git a/tdehtml/css/csshelper.cpp b/tdehtml/css/csshelper.cpp
new file mode 100644
index 000000000..02b5b3d39
--- /dev/null
+++ b/tdehtml/css/csshelper.cpp
@@ -0,0 +1,87 @@
+/*
+ * This file is part of the CSS implementation for KDE.
+ *
+ * Copyright (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.
+ *
+ */
+#include "csshelper.h"
+
+#include <tqfontmetrics.h>
+#include <tqfontinfo.h>
+#include <tqpaintdevice.h>
+#include <tqpaintdevicemetrics.h>
+#include <tqfontdatabase.h>
+
+#include <kcharsets.h>
+#include <kglobal.h>
+#include <kdebug.h>
+
+#include "rendering/render_style.h"
+#include "css_valueimpl.h"
+#include "dom/css_value.h"
+#include "misc/helper.h"
+#include "xml/dom_stringimpl.h"
+#include "tdehtml_settings.h"
+
+using namespace DOM;
+using namespace tdehtml;
+
+
+DOMString tdehtml::parseURL(const DOMString &url)
+{
+    DOMStringImpl* i = url.implementation();
+    if(!i) return DOMString();
+
+    int o = 0;
+    int l = i->l;
+    while(o < l && (i->s[o] <= TQChar(' '))) { o++; l--; }
+    while(l > 0 && (i->s[o+l-1] <= TQChar(' '))) l--;
+
+    if(l >= 5 &&
+       (i->s[o].lower() == 'u') &&
+       (i->s[o+1].lower() == 'r') &&
+       (i->s[o+2].lower() == 'l') &&
+       i->s[o+3].latin1() == '(' &&
+       i->s[o+l-1].latin1() == ')') {
+        o += 4;
+        l -= 5;
+    }
+
+    while(o < l && (i->s[o] <= TQChar(' '))) { o++; l--; }
+    while(l > 0 && (i->s[o+l-1] <= TQChar(' '))) l--;
+
+    if(l >= 2 && i->s[o] == i->s[o+l-1] &&
+       (i->s[o].latin1() == '\'' || i->s[o].latin1() == '\"')) {
+        o++;
+        l -= 2;
+    }
+
+    while(o < l && (i->s[o] <= TQChar(' '))) { o++; l--; }
+    while(l > 0 && (i->s[o+l-1] <= TQChar(' '))) l--;
+
+    DOMStringImpl* j = new DOMStringImpl(i->s+o,l);
+
+    int nl = 0;
+    for(int k = o; k < o+l; k++)
+        if(i->s[k].unicode() > '\r')
+            j->s[nl++] = i->s[k];
+
+    j->l = nl;
+
+    return j;
+}
diff --git a/tdehtml/css/csshelper.h b/tdehtml/css/csshelper.h
new file mode 100644
index 000000000..772a9eba1
--- /dev/null
+++ b/tdehtml/css/csshelper.h
@@ -0,0 +1,51 @@
+/*
+ * This file is part of the CSS implementation for KDE.
+ *
+ * Copyright (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.
+ *
+ */
+#ifndef css_helper_h
+#define css_helper_h
+
+#include <tqcolor.h>
+#include <tqfont.h>
+
+#include "dom/dom_string.h"
+
+class TQPaintDeviceMetrics;
+class KHTMLSettings;
+
+namespace DOM
+{
+    class CSSPrimitiveValueImpl;
+}
+
+namespace tdehtml
+{
+    class RenderStyle;
+
+    /*
+     * mostly just removes the url("...") brace
+     */
+    DOM::DOMString parseURL(const DOM::DOMString &url);
+
+}
+
+
+
+#endif
diff --git a/tdehtml/css/cssparser.cpp b/tdehtml/css/cssparser.cpp
new file mode 100644
index 000000000..b994ad773
--- /dev/null
+++ b/tdehtml/css/cssparser.cpp
@@ -0,0 +1,2614 @@
+/*
+ * This file is part of the DOM implementation for KDE.
+ *
+ * Copyright (C) 2003 Lars Knoll (knoll@kde.org)
+ * Copyright (C) 2005 Allan Sandfeld Jensen (kde@carewolf.com)
+ * Copyright (C) 2004, 2005, 2006 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.
+ */
+
+// #define CSS_DEBUG
+// #define TOKEN_DEBUG
+#define YYDEBUG 0
+
+#include <kdebug.h>
+#include <kglobal.h>
+#include <kurl.h>
+
+#include "cssparser.h"
+#include "css_valueimpl.h"
+#include "css_ruleimpl.h"
+#include "css_stylesheetimpl.h"
+#include "cssproperties.h"
+#include "cssvalues.h"
+#include "misc/helper.h"
+#include "csshelper.h"
+using namespace DOM;
+
+#include <stdlib.h>
+#include <assert.h>
+
+// used to promote background: left to left center
+#define BACKGROUND_SKIP_CENTER( num ) \
+    if ( !pos_ok[ num ] && expected != 1 ) {    \
+        pos_ok[num] = true; \
+        pos[num] = 0; \
+        skip_next = false; \
+    }
+
+ValueList::~ValueList()
+{
+     unsigned numValues = m_values.size();
+     for (unsigned i = 0; i < numValues; i++)
+         if (m_values[i].unit == Value::Function)
+             delete m_values[i].function;
+}
+
+namespace {
+    class ShorthandScope {
+    public:
+        ShorthandScope(CSSParser* parser, int propId) : m_parser(parser)
+        {
+            if (!(m_parser->m_inParseShorthand++))
+                m_parser->m_currentShorthand = propId;
+        }
+        ~ShorthandScope()
+        {
+            if (!(--m_parser->m_inParseShorthand))
+                m_parser->m_currentShorthand = 0;
+        }
+
+    private:
+        CSSParser* m_parser;
+    };
+}
+
+using namespace DOM;
+
+#if YYDEBUG > 0
+extern int cssyydebug;
+#endif
+
+extern int cssyyparse( void * parser );
+
+CSSParser *CSSParser::currentParser = 0;
+
+CSSParser::CSSParser( bool strictParsing )
+{
+#ifdef CSS_DEBUG
+    kdDebug( 6080 ) << "CSSParser::CSSParser this=" << this << endl;
+#endif
+    strict = strictParsing;
+
+    parsedProperties = (CSSProperty **) malloc( 32 * sizeof( CSSProperty * ) );
+    numParsedProperties = 0;
+    maxParsedProperties = 32;
+
+    data = 0;
+    valueList = 0;
+    rule = 0;
+    id = 0;
+    important = false;
+    nonCSSHint = false;
+
+    m_inParseShorthand = 0;
+    m_currentShorthand = 0;
+    m_implicitShorthand = false;
+
+    yy_start = 1;
+
+#if YYDEBUG > 0
+    cssyydebug = 1;
+#endif
+
+}
+
+CSSParser::~CSSParser()
+{
+    if ( numParsedProperties )
+        clearProperties();
+    free( parsedProperties );
+
+    delete valueList;
+
+#ifdef CSS_DEBUG
+    kdDebug( 6080 ) << "CSSParser::~CSSParser this=" << this << endl;
+#endif
+
+    free( data );
+
+}
+
+unsigned int CSSParser::defaultNamespace()
+{
+    if (styleElement && styleElement->isCSSStyleSheet())
+        return static_cast<CSSStyleSheetImpl*>(styleElement)->defaultNamespace();
+    else
+        return anyNamespace;
+}
+
+void CSSParser::runParser(int length)
+{
+    data[length-1] = 0;
+    data[length-2] = 0;
+    data[length-3] = ' ';
+
+    yyTok = -1;
+    block_nesting = 0;
+    yy_hold_char = 0;
+    yyleng = 0;
+    yytext = yy_c_buf_p = data;
+    yy_hold_char = *yy_c_buf_p;
+
+    CSSParser *old = currentParser;
+    currentParser = this;
+    cssyyparse( this );
+    currentParser = old;
+}
+
+void CSSParser::parseSheet( CSSStyleSheetImpl *sheet, const DOMString &string )
+{
+    styleElement = sheet;
+
+    int length = string.length() + 3;
+    data = (unsigned short *)malloc( length *sizeof( unsigned short ) );
+    memcpy( data, string.unicode(), string.length()*sizeof( unsigned short) );
+
+#ifdef CSS_DEBUG
+    kdDebug( 6080 ) << ">>>>>>> start parsing style sheet" << endl;
+#endif
+    runParser(length);
+#ifdef CSS_DEBUG
+    kdDebug( 6080 ) << "<<<<<<< done parsing style sheet" << endl;
+#endif
+
+    delete rule;
+    rule = 0;
+}
+
+CSSRuleImpl *CSSParser::parseRule( DOM::CSSStyleSheetImpl *sheet, const DOM::DOMString &string )
+{
+    styleElement = sheet;
+
+    const char tdehtml_rule[] = "@-tdehtml-rule{";
+    int length = string.length() + 4 + strlen(tdehtml_rule);
+    assert( !data );
+    data = (unsigned short *)malloc( length *sizeof( unsigned short ) );
+    for ( unsigned int i = 0; i < strlen(tdehtml_rule); i++ )
+        data[i] = tdehtml_rule[i];
+    memcpy( data + strlen( tdehtml_rule ), string.unicode(), string.length()*sizeof( unsigned short) );
+    // tqDebug("parse string = '%s'", TQConstString( (const TQChar *)data, length ).string().latin1() );
+    data[length-4] = '}';
+
+    runParser(length);
+
+    CSSRuleImpl *result = rule;
+    rule = 0;
+
+    return result;
+}
+
+bool CSSParser::parseValue( DOM::CSSStyleDeclarationImpl *declaration, int _id, const DOM::DOMString &string,
+                            bool _important, bool _nonCSSHint )
+{
+#ifdef CSS_DEBUG
+    kdDebug( 6080 ) << "CSSParser::parseValue: id=" << _id << " important=" << _important
+                    << " nonCSSHint=" << _nonCSSHint << " value='" << string.string() << "'" << endl;
+#endif
+
+    styleElement = declaration->stylesheet();
+
+    const char tdehtml_value[] = "@-tdehtml-value{";
+    int length = string.length() + 4 + strlen(tdehtml_value);
+    assert( !data );
+    data = (unsigned short *)malloc( length *sizeof( unsigned short ) );
+    for ( unsigned int i = 0; i < strlen(tdehtml_value); i++ )
+        data[i] = tdehtml_value[i];
+    memcpy( data + strlen( tdehtml_value ), string.unicode(), string.length()*sizeof( unsigned short) );
+    data[length-4] = '}';
+    // tqDebug("parse string = '%s'", TQConstString( (const TQChar *)data, length ).string().latin1() );
+
+    id = _id;
+    important = _important;
+    nonCSSHint = _nonCSSHint;
+
+    runParser(length);
+
+    delete rule;
+    rule = 0;
+
+    bool ok = false;
+    if ( numParsedProperties ) {
+        ok = true;
+        for ( int i = 0; i < numParsedProperties; i++ ) {
+            declaration->removeProperty(parsedProperties[i]->m_id, nonCSSHint);
+            declaration->values()->append( parsedProperties[i] );
+        }
+        numParsedProperties = 0;
+    }
+
+    return ok;
+}
+
+bool CSSParser::parseDeclaration( DOM::CSSStyleDeclarationImpl *declaration, const DOM::DOMString &string,
+                                  bool _nonCSSHint )
+{
+#ifdef CSS_DEBUG
+    kdDebug( 6080 ) << "CSSParser::parseDeclaration: nonCSSHint=" << nonCSSHint
+                    << " value='" << string.string() << "'" << endl;
+#endif
+
+    styleElement = declaration->stylesheet();
+
+    const char tdehtml_decls[] = "@-tdehtml-decls{";
+    int length = string.length() + 4 + strlen(tdehtml_decls);
+    assert( !data );
+    data = (unsigned short *)malloc( length *sizeof( unsigned short ) );
+    for ( unsigned int i = 0; i < strlen(tdehtml_decls); i++ )
+        data[i] = tdehtml_decls[i];
+    memcpy( data + strlen( tdehtml_decls ), string.unicode(), string.length()*sizeof( unsigned short) );
+    data[length-4] = '}';
+
+    nonCSSHint = _nonCSSHint;
+
+    runParser(length);
+
+    delete rule;
+    rule = 0;
+
+    bool ok = false;
+    if ( numParsedProperties ) {
+        ok = true;
+        for ( int i = 0; i < numParsedProperties; i++ ) {
+            declaration->removeProperty(parsedProperties[i]->m_id, false);
+            declaration->values()->append( parsedProperties[i] );
+        }
+        numParsedProperties = 0;
+    }
+
+    return ok;
+}
+
+void CSSParser::addProperty( int propId, CSSValueImpl *value, bool important )
+{
+    CSSProperty *prop = new CSSProperty;
+    prop->m_id = propId;
+    prop->setValue( value );
+    prop->m_important = important;
+    prop->nonCSSHint = nonCSSHint;
+
+    if ( numParsedProperties >= maxParsedProperties ) {
+        maxParsedProperties += 32;
+        parsedProperties = (CSSProperty **) realloc( parsedProperties,
+                                                    maxParsedProperties*sizeof( CSSProperty * ) );
+    }
+    parsedProperties[numParsedProperties++] = prop;
+}
+
+CSSStyleDeclarationImpl *CSSParser::createStyleDeclaration( CSSStyleRuleImpl *rule )
+{
+    TQPtrList<CSSProperty> *propList = new TQPtrList<CSSProperty>;
+    propList->setAutoDelete( true );
+    for ( int i = 0; i < numParsedProperties; i++ )
+        propList->append( parsedProperties[i] );
+
+    numParsedProperties = 0;
+    return new CSSStyleDeclarationImpl(rule, propList);
+}
+
+void CSSParser::clearProperties()
+{
+    for ( int i = 0; i < numParsedProperties; i++ )
+        delete parsedProperties[i];
+    numParsedProperties = 0;
+}
+
+DOM::DocumentImpl *CSSParser::document() const
+{
+    const StyleBaseImpl* root = styleElement;
+    DocumentImpl *doc = 0;
+    while (root->parent())
+        root = root->parent();
+    if (root->isCSSStyleSheet())
+        doc = static_cast<const CSSStyleSheetImpl*>(root)->doc();
+    return doc;
+}
+
+
+// defines units allowed for a certain property, used in parseUnit
+enum Units
+{
+    FUnknown   = 0x0000,
+    FInteger   = 0x0001,
+    FNumber    = 0x0002,  // Real Numbers
+    FPercent   = 0x0004,
+    FLength    = 0x0008,
+    FAngle     = 0x0010,
+    FTime      = 0x0020,
+    FFrequency = 0x0040,
+    FRelative  = 0x0100,
+    FNonNeg    = 0x0200
+};
+
+static bool validUnit( Value *value, int unitflags, bool strict )
+{
+    if ( unitflags & FNonNeg && value->fValue < 0 )
+        return false;
+
+    bool b = false;
+    switch( value->unit ) {
+    case CSSPrimitiveValue::CSS_NUMBER:
+        b = (unitflags & FNumber);
+        if ( !b && ( (unitflags & FLength) && (value->fValue == 0 || !strict ) ) ) {
+            value->unit = CSSPrimitiveValue::CSS_PX;
+            b = true;
+        }
+        if (!b && (unitflags & FInteger) && value->isInt)
+            b = true;
+        break;
+    case CSSPrimitiveValue::CSS_PERCENTAGE:
+        b = (unitflags & FPercent);
+        break;
+    case Value::Q_EMS:
+    case CSSPrimitiveValue::CSS_EMS:
+    case CSSPrimitiveValue::CSS_EXS:
+    case CSSPrimitiveValue::CSS_PX:
+    case CSSPrimitiveValue::CSS_CM:
+    case CSSPrimitiveValue::CSS_MM:
+    case CSSPrimitiveValue::CSS_IN:
+    case CSSPrimitiveValue::CSS_PT:
+    case CSSPrimitiveValue::CSS_PC:
+        b = (unitflags & FLength);
+        break;
+    case CSSPrimitiveValue::CSS_MS:
+    case CSSPrimitiveValue::CSS_S:
+        b = (unitflags & FTime);
+        break;
+    case CSSPrimitiveValue::CSS_DEG:
+    case CSSPrimitiveValue::CSS_RAD:
+    case CSSPrimitiveValue::CSS_GRAD:
+    case CSSPrimitiveValue::CSS_HZ:
+    case CSSPrimitiveValue::CSS_KHZ:
+    case CSSPrimitiveValue::CSS_DIMENSION:
+    default:
+        break;
+    }
+    return b;
+}
+
+bool CSSParser::parseValue( int propId, bool important )
+{
+    if ( !valueList ) return false;
+
+    Value *value = valueList->current();
+
+    if ( !value )
+        return false;
+
+    int id = value->id;
+
+    int num = inShorthand() ? 1 : valueList->size();
+
+    if ( id == CSS_VAL_INHERIT ) {
+        if (num != 1)
+            return false;
+        addProperty( propId, new CSSInheritedValueImpl(), important );
+        return true;
+    } else if (id == CSS_VAL_INITIAL ) {
+        if (num != 1)
+            return false;
+        addProperty(propId, new CSSInitialValueImpl(), important);
+        return true;
+    }
+
+    bool valid_primitive = false;
+    CSSValueImpl *parsedValue = 0;
+
+    switch(propId) {
+        /* The comment to the left defines all valid value of this properties as defined
+         * in CSS 2, Appendix F. Property index
+         */
+
+        /* All the CSS properties are not supported by the renderer at the moment.
+         * Note that all the CSS2 Aural properties are only checked, if CSS_AURAL is defined
+         * (see parseAuralValues). As we don't support them at all this seems reasonable.
+         */
+
+    case CSS_PROP_SIZE:                 // <length>{1,2} | auto | portrait | landscape | inherit
+//     case CSS_PROP_PAGE:                 // <identifier> | auto // ### CHECK
+        // ### To be done
+        if (id)
+            valid_primitive = true;
+        break;
+    case CSS_PROP_UNICODE_BIDI:         // normal | embed | bidi-override | inherit
+        if ( id == CSS_VAL_NORMAL ||
+             id == CSS_VAL_EMBED ||
+             id == CSS_VAL_BIDI_OVERRIDE )
+            valid_primitive = true;
+        break;
+
+    case CSS_PROP_POSITION:             // static | relative | absolute | fixed | inherit
+        if ( id == CSS_VAL_STATIC ||
+             id == CSS_VAL_RELATIVE ||
+             id == CSS_VAL_ABSOLUTE ||
+              id == CSS_VAL_FIXED )
+            valid_primitive = true;
+        break;
+
+    case CSS_PROP_PAGE_BREAK_AFTER:     // auto | always | avoid | left | right | inherit
+    case CSS_PROP_PAGE_BREAK_BEFORE:    // auto | always | avoid | left | right | inherit
+        if ( id == CSS_VAL_AUTO ||
+             id == CSS_VAL_ALWAYS ||
+             id == CSS_VAL_AVOID ||
+              id == CSS_VAL_LEFT ||
+              id == CSS_VAL_RIGHT )
+            valid_primitive = true;
+        break;
+
+    case CSS_PROP_PAGE_BREAK_INSIDE:    // avoid | auto | inherit
+        if ( id == CSS_VAL_AUTO ||
+             id == CSS_VAL_AVOID )
+            valid_primitive = true;
+        break;
+
+    case CSS_PROP_EMPTY_CELLS:          // show | hide | inherit
+        if ( id == CSS_VAL_SHOW ||
+             id == CSS_VAL_HIDE )
+            valid_primitive = true;
+        break;
+
+    case CSS_PROP_QUOTES:               // [<string> <string>]+ | none | inherit
+        if (id == CSS_VAL_NONE) {
+            valid_primitive = true;
+        } else {
+            QuotesValueImpl *quotes = new QuotesValueImpl;
+            bool is_valid = true;
+            TQString open, close;
+            Value *val=valueList->current();
+            while (val) {
+                if (val->unit == CSSPrimitiveValue::CSS_STRING)
+                    open = qString(val->string);
+                else {
+                    is_valid = false;
+                    break;
+                }
+                valueList->next();
+                val=valueList->current();
+                if (val && val->unit == CSSPrimitiveValue::CSS_STRING)
+                    close = qString(val->string);
+                else {
+                    is_valid = false;
+                    break;
+                }
+                quotes->addLevel(open, close);
+                valueList->next();
+                val=valueList->current();
+            }
+            if (is_valid)
+                parsedValue = quotes;
+            else
+                delete quotes;
+        }
+        break;
+
+    case CSS_PROP_CONTENT:     //  normal | none | inherit |
+        // [ <string> | <uri> | <counter> | attr(X) | open-quote | close-quote | no-open-quote | no-close-quote ]+
+        if ( id == CSS_VAL_NORMAL || id == CSS_VAL_NONE)
+            valid_primitive = true;
+        else
+            return parseContent( propId, important );
+        break;
+
+    case CSS_PROP_WHITE_SPACE:          // normal | pre | nowrap | pre-wrap | pre-line | inherit
+        if ( id == CSS_VAL_NORMAL ||
+             id == CSS_VAL_PRE ||
+             id == CSS_VAL_PRE_WRAP ||
+             id == CSS_VAL_PRE_LINE ||
+             id == CSS_VAL_NOWRAP )
+            valid_primitive = true;
+        break;
+
+    case CSS_PROP_CLIP:                 // <shape> | auto | inherit
+        if ( id == CSS_VAL_AUTO )
+            valid_primitive = true;
+        else if ( value->unit == Value::Function )
+            return parseShape( propId, important );
+        break;
+
+    /* Start of supported CSS properties with validation. This is needed for parseShortHand to work
+     * correctly and allows optimization in tdehtml::applyRule(..)
+     */
+    case CSS_PROP_CAPTION_SIDE:         // top | bottom | left | right | inherit
+        // Left and right were deprecated in CSS 2.1 and never supported by KHTML
+        if ( /* id == CSS_VAL_LEFT || id == CSS_VAL_RIGHT || */
+            id == CSS_VAL_TOP || id == CSS_VAL_BOTTOM)
+            valid_primitive = true;
+        break;
+
+    case CSS_PROP_BORDER_COLLAPSE:      // collapse | separate | inherit
+        if ( id == CSS_VAL_COLLAPSE || id == CSS_VAL_SEPARATE )
+            valid_primitive = true;
+        break;
+
+    case CSS_PROP_VISIBILITY:           // visible | hidden | collapse | inherit
+        if (id == CSS_VAL_VISIBLE || id == CSS_VAL_HIDDEN || id == CSS_VAL_COLLAPSE)
+            valid_primitive = true;
+        break;
+
+    case CSS_PROP_OVERFLOW:             // visible | hidden | scroll | auto | marquee | inherit
+    case CSS_PROP_OVERFLOW_X:
+    case CSS_PROP_OVERFLOW_Y:
+        if (id == CSS_VAL_VISIBLE || id == CSS_VAL_HIDDEN || id == CSS_VAL_SCROLL || id == CSS_VAL_AUTO ||
+            id == CSS_VAL_MARQUEE)
+            valid_primitive = true;
+        break;
+
+    case CSS_PROP_LIST_STYLE_POSITION:  // inside | outside | inherit
+        if ( id == CSS_VAL_INSIDE || id == CSS_VAL_OUTSIDE )
+            valid_primitive = true;
+        break;
+
+    case CSS_PROP_LIST_STYLE_TYPE:
+        // disc | circle | square | decimal | decimal-leading-zero | lower-roman |
+        // upper-roman | lower-greek | lower-alpha | lower-latin | upper-alpha |
+        // upper-latin | hebrew | armenian | georgian | cjk-ideographic | hiragana |
+        // katakana | hiragana-iroha | katakana-iroha | none | inherit
+        if ((id >= CSS_VAL_DISC && id <= CSS_VAL__KHTML_CLOSE_QUOTE) || id == CSS_VAL_NONE)
+            valid_primitive = true;
+        break;
+
+    case CSS_PROP_DISPLAY:
+        // inline | block | list-item | run-in | inline-block | -tdehtml-ruler | table |
+        // inline-table | table-row-group | table-header-group | table-footer-group | table-row |
+        // table-column-group | table-column | table-cell | table-caption | none | inherit
+        if ((id >= CSS_VAL_INLINE && id <= CSS_VAL_TABLE_CAPTION) || id == CSS_VAL_NONE)
+            valid_primitive = true;
+        break;
+
+    case CSS_PROP_DIRECTION:            // ltr | rtl | inherit
+        if ( id == CSS_VAL_LTR || id == CSS_VAL_RTL )
+            valid_primitive = true;
+        break;
+
+    case CSS_PROP_TEXT_TRANSFORM:       // capitalize | uppercase | lowercase | none | inherit
+        if ((id >= CSS_VAL_CAPITALIZE && id <= CSS_VAL_LOWERCASE) || id == CSS_VAL_NONE)
+            valid_primitive = true;
+        break;
+
+    case CSS_PROP_FLOAT:                // left | right | none | tdehtml_left | tdehtml_right | inherit + center for buggy CSS
+        if ( id == CSS_VAL_LEFT || id == CSS_VAL_RIGHT || id == CSS_VAL__KHTML_LEFT ||
+             id == CSS_VAL__KHTML_RIGHT ||id == CSS_VAL_NONE || id == CSS_VAL_CENTER)
+            valid_primitive = true;
+        break;
+
+    case CSS_PROP_CLEAR:                // none | left | right | both | inherit
+        if ( id == CSS_VAL_NONE || id == CSS_VAL_LEFT ||
+             id == CSS_VAL_RIGHT|| id == CSS_VAL_BOTH)
+            valid_primitive = true;
+        break;
+
+    case CSS_PROP_TEXT_ALIGN:
+        // left | right | center | justify | tdehtml_left | tdehtml_right | tdehtml_center | <string> | inherit
+        if ( ( id >= CSS_VAL__KHTML_AUTO && id <= CSS_VAL__KHTML_CENTER ) ||
+             value->unit == CSSPrimitiveValue::CSS_STRING )
+            valid_primitive = true;
+        break;
+
+    case CSS_PROP_OUTLINE_STYLE:        // <border-style> | inherit
+    case CSS_PROP_BORDER_TOP_STYLE:     //// <border-style> | inherit
+    case CSS_PROP_BORDER_RIGHT_STYLE:   //   Defined as:    none | hidden | dotted | dashed |
+    case CSS_PROP_BORDER_BOTTOM_STYLE:  //   solid | double | groove | ridge | inset | outset | -tdehtml-native
+    case CSS_PROP_BORDER_LEFT_STYLE:    ////
+        if (id >= CSS_VAL__KHTML_NATIVE && id <= CSS_VAL_DOUBLE)
+            valid_primitive = true;
+        break;
+
+    case CSS_PROP_FONT_WEIGHT:  // normal | bold | bolder | lighter | 100 | 200 | 300 | 400 |
+        // 500 | 600 | 700 | 800 | 900 | inherit
+        if (id >= CSS_VAL_NORMAL && id <= CSS_VAL_900) {
+            // Allready correct id
+            valid_primitive = true;
+        } else if ( validUnit( value, FInteger|FNonNeg, false ) ) {
+            int weight = (int)value->fValue;
+            if ( (weight % 100) )
+                break;
+            weight /= 100;
+            if ( weight >= 1 && weight <= 9 ) {
+                id = CSS_VAL_100 + weight - 1;
+                valid_primitive = true;
+            }
+        }
+        break;
+
+    case CSS_PROP_BORDER_SPACING:
+    {
+        const int properties[2] = { CSS_PROP__KHTML_BORDER_HORIZONTAL_SPACING,
+                                    CSS_PROP__KHTML_BORDER_VERTICAL_SPACING };
+        if (num == 1) {
+            ShorthandScope scope(this, CSS_PROP_BORDER_SPACING);
+            if (!parseValue(properties[0], important)) return false;
+            CSSValueImpl* value = parsedProperties[numParsedProperties-1]->value();
+            addProperty(properties[1], value, important);
+            return true;
+        }
+        else if (num == 2) {
+            ShorthandScope scope(this, CSS_PROP_BORDER_SPACING);
+            if (!parseValue(properties[0], important)) return false;
+            if (!parseValue(properties[1], important)) return false;
+            return true;
+        }
+        return false;
+    }
+    case CSS_PROP__KHTML_BORDER_HORIZONTAL_SPACING:
+    case CSS_PROP__KHTML_BORDER_VERTICAL_SPACING:
+        valid_primitive = validUnit(value, FLength|FNonNeg, strict&(!nonCSSHint));
+        break;
+
+    case CSS_PROP_SCROLLBAR_FACE_COLOR:         // IE5.5
+    case CSS_PROP_SCROLLBAR_SHADOW_COLOR:       // IE5.5
+    case CSS_PROP_SCROLLBAR_HIGHLIGHT_COLOR:    // IE5.5
+    case CSS_PROP_SCROLLBAR_3DLIGHT_COLOR:      // IE5.5
+    case CSS_PROP_SCROLLBAR_DARKSHADOW_COLOR:   // IE5.5
+    case CSS_PROP_SCROLLBAR_TRACK_COLOR:        // IE5.5
+    case CSS_PROP_SCROLLBAR_ARROW_COLOR:        // IE5.5
+    case CSS_PROP_SCROLLBAR_BASE_COLOR:         // IE5.5
+        if ( strict )
+            break;
+        /* nobreak */
+    case CSS_PROP_OUTLINE_COLOR:        // <color> | invert | inherit
+        // outline has "invert" as additional keyword.
+        if ( propId == CSS_PROP_OUTLINE_COLOR && id == CSS_VAL_INVERT ) {
+            valid_primitive = true;
+            break;
+        }
+        /* nobreak */
+    case CSS_PROP_BACKGROUND_COLOR:     // <color> | inherit
+    case CSS_PROP_BORDER_TOP_COLOR:     // <color> | inherit
+    case CSS_PROP_BORDER_RIGHT_COLOR:   // <color> | inherit
+    case CSS_PROP_BORDER_BOTTOM_COLOR:  // <color> | inherit
+    case CSS_PROP_BORDER_LEFT_COLOR:    // <color> | inherit
+    case CSS_PROP_COLOR:                // <color> | inherit
+        if ( id == CSS_VAL__KHTML_TEXT || id == CSS_VAL_MENU ||
+             (id >= CSS_VAL_AQUA && id <= CSS_VAL_WINDOWTEXT ) ||
+             id == CSS_VAL_TRANSPARENT ||
+             (id >= CSS_VAL_GREY && id < CSS_VAL__KHTML_TEXT && (nonCSSHint|!strict) ) ) {
+            valid_primitive = true;
+        } else {
+            parsedValue = parseColor();
+            if ( parsedValue )
+                valueList->next();
+        }
+        break;
+
+    case CSS_PROP_CURSOR:
+        //  [ auto | crosshair | default | pointer | progress | move | e-resize | ne-resize |
+        // nw-resize | n-resize | se-resize | sw-resize | s-resize | w-resize | text |
+        // wait | help ] ] | inherit
+    // MSIE 5 compatibility :/
+        if ( !strict && id == CSS_VAL_HAND ) {
+            id = CSS_VAL_POINTER;
+            valid_primitive = true;
+        } else if ( id >= CSS_VAL_AUTO && id <= CSS_VAL_HELP )
+            valid_primitive = true;
+        break;
+
+    case CSS_PROP_BACKGROUND_ATTACHMENT:
+    case CSS_PROP__KHTML_BACKGROUND_CLIP:
+    case CSS_PROP_BACKGROUND_IMAGE:
+    case CSS_PROP__KHTML_BACKGROUND_ORIGIN:
+    case CSS_PROP_BACKGROUND_POSITION:
+    case CSS_PROP_BACKGROUND_POSITION_X:
+    case CSS_PROP_BACKGROUND_POSITION_Y:
+    case CSS_PROP__KHTML_BACKGROUND_SIZE:
+    case CSS_PROP_BACKGROUND_REPEAT: {
+        CSSValueImpl *val1 = 0, *val2 = 0;
+        int propId1, propId2;
+        if (parseBackgroundProperty(propId, propId1, propId2, val1, val2)) {
+            addProperty(propId1, val1, important);
+            if (val2)
+                addProperty(propId2, val2, important);
+            return true;
+        }
+        return false;
+    }
+    case CSS_PROP_LIST_STYLE_IMAGE:     // <uri> | none | inherit
+        if (id == CSS_VAL_NONE) {
+            parsedValue = new CSSImageValueImpl();
+            valueList->next();
+        }
+        else if (value->unit == CSSPrimitiveValue::CSS_URI ) {
+            // ### allow string in non strict mode?
+            DOMString uri = tdehtml::parseURL( domString( value->string ) );
+            if (!uri.isEmpty()) {
+                parsedValue = new CSSImageValueImpl(
+                    DOMString(KURL( styleElement->baseURL(), uri.string()).url()),
+                    styleElement );
+                valueList->next();
+            }
+        }
+        break;
+
+    case CSS_PROP_OUTLINE_WIDTH:        // <border-width> | inherit
+    case CSS_PROP_BORDER_TOP_WIDTH:     //// <border-width> | inherit
+    case CSS_PROP_BORDER_RIGHT_WIDTH:   //   Which is defined as
+    case CSS_PROP_BORDER_BOTTOM_WIDTH:  //   thin | medium | thick | <length>
+    case CSS_PROP_BORDER_LEFT_WIDTH:    ////
+        if (id == CSS_VAL_THIN || id == CSS_VAL_MEDIUM || id == CSS_VAL_THICK)
+            valid_primitive = true;
+        else
+            valid_primitive = ( validUnit( value, FLength, strict&(!nonCSSHint) ) );
+        break;
+
+    case CSS_PROP_LETTER_SPACING:       // normal | <length> | inherit
+    case CSS_PROP_WORD_SPACING:         // normal | <length> | inherit
+        if ( id == CSS_VAL_NORMAL )
+            valid_primitive = true;
+        else
+            valid_primitive = validUnit( value, FLength, strict&(!nonCSSHint) );
+        break;
+
+    case CSS_PROP_TEXT_INDENT:          //  <length> | <percentage> | inherit
+        valid_primitive = ( !id && validUnit( value, FLength|FPercent, strict&(!nonCSSHint) ) );
+        break;
+
+    case CSS_PROP_PADDING_TOP:          //  <length> | <percentage> | inherit
+    case CSS_PROP_PADDING_RIGHT:        //  <padding-width> | inherit
+    case CSS_PROP_PADDING_BOTTOM:       //   Which is defined as
+    case CSS_PROP_PADDING_LEFT:         //   <length> | <percentage>
+    case CSS_PROP__KHTML_PADDING_START:
+        valid_primitive = ( !id && validUnit( value, FLength|FPercent|FNonNeg, strict&(!nonCSSHint) ) );
+        break;
+
+    case CSS_PROP_MAX_HEIGHT:           // <length> | <percentage> | none | inherit
+    case CSS_PROP_MAX_WIDTH:            // <length> | <percentage> | none | inherit
+        if ( id == CSS_VAL_NONE ) {
+            valid_primitive = true;
+            break;
+        }
+        /* nobreak */
+    case CSS_PROP_MIN_HEIGHT:           // <length> | <percentage> | inherit
+    case CSS_PROP_MIN_WIDTH:            // <length> | <percentage> | inherit
+            valid_primitive = ( !id && validUnit( value, FLength|FPercent|FNonNeg, strict&(!nonCSSHint) ) );
+        break;
+
+    case CSS_PROP_FONT_SIZE:
+            // <absolute-size> | <relative-size> | <length> | <percentage> | inherit
+        if (id >= CSS_VAL_XX_SMALL && id <= CSS_VAL_LARGER)
+            valid_primitive = true;
+        else
+            valid_primitive = ( validUnit( value, FLength|FPercent, strict&(!nonCSSHint) ) );
+        break;
+
+    case CSS_PROP_FONT_STYLE:           // normal | italic | oblique | inherit
+        if ( id == CSS_VAL_NORMAL || id == CSS_VAL_ITALIC || id == CSS_VAL_OBLIQUE)
+            valid_primitive = true;
+        break;
+
+    case CSS_PROP_FONT_VARIANT:         // normal | small-caps | inherit
+        if ( id == CSS_VAL_NORMAL || id == CSS_VAL_SMALL_CAPS)
+            valid_primitive = true;
+        break;
+
+    case CSS_PROP_VERTICAL_ALIGN:
+            // baseline | sub | super | top | text-top | middle | bottom | text-bottom |
+        // <percentage> | <length> | inherit
+
+        if ( id >= CSS_VAL_BASELINE && id <= CSS_VAL__KHTML_BASELINE_MIDDLE )
+            valid_primitive = true;
+        else
+            valid_primitive = ( !id && validUnit( value, FLength|FPercent, strict&(!nonCSSHint) ) );
+        break;
+
+    case CSS_PROP_HEIGHT:               // <length> | <percentage> | auto | inherit
+    case CSS_PROP_WIDTH:                // <length> | <percentage> | auto | inherit
+        if ( id == CSS_VAL_AUTO )
+            valid_primitive = true;
+        else
+            // ### handle multilength case where we allow relative units
+            valid_primitive = ( !id && validUnit( value, FLength|FPercent|FNonNeg, strict&(!nonCSSHint) ) );
+        break;
+
+    case CSS_PROP_BOTTOM:               // <length> | <percentage> | auto | inherit
+    case CSS_PROP_LEFT:                 // <length> | <percentage> | auto | inherit
+    case CSS_PROP_RIGHT:                // <length> | <percentage> | auto | inherit
+    case CSS_PROP_TOP:                  // <length> | <percentage> | auto | inherit
+    case CSS_PROP_MARGIN_TOP:           //// <margin-width> | inherit
+    case CSS_PROP_MARGIN_RIGHT:         //   Which is defined as
+    case CSS_PROP_MARGIN_BOTTOM:        //   <length> | <percentage> | auto | inherit
+    case CSS_PROP_MARGIN_LEFT:          ////
+    case CSS_PROP__KHTML_MARGIN_START:
+        if ( id == CSS_VAL_AUTO )
+            valid_primitive = true;
+        else
+            valid_primitive = ( !id && validUnit( value, FLength|FPercent, strict&(!nonCSSHint) ) );
+        break;
+
+    case CSS_PROP_Z_INDEX:              // auto | <integer> | inherit
+        // tqDebug("parsing z-index: id=%d, fValue=%f", id, value->fValue );
+        if ( id == CSS_VAL_AUTO ) {
+            valid_primitive = true;
+            break;
+        }
+        /* nobreak */
+    case CSS_PROP_ORPHANS:              // <integer> | inherit
+    case CSS_PROP_WIDOWS:               // <integer> | inherit
+        // ### not supported later on
+        valid_primitive = ( !id && validUnit( value, FInteger, false ) );
+        break;
+
+    case CSS_PROP_LINE_HEIGHT:          // normal | <number> | <length> | <percentage> | inherit
+        if ( id == CSS_VAL_NORMAL )
+            valid_primitive = true;
+        else
+            valid_primitive = ( !id && validUnit( value, FNumber|FLength|FPercent, strict&(!nonCSSHint) ) );
+        break;
+    case CSS_PROP_COUNTER_INCREMENT:    // [ <identifier> <integer>? ]+ | none | inherit
+        if ( id == CSS_VAL_NONE )
+            valid_primitive = true;
+        else
+            return parseCounter(propId, true, important);
+        break;
+    case CSS_PROP_COUNTER_RESET:        // [ <identifier> <integer>? ]+ | none | inherit
+        if ( id == CSS_VAL_NONE )
+            valid_primitive = true;
+        else
+            return parseCounter(propId, false, important);
+            break;
+
+    case CSS_PROP_FONT_FAMILY:
+            // [[ <family-name> | <generic-family> ],]* [<family-name> | <generic-family>] | inherit
+    {
+        parsedValue = parseFontFamily();
+        break;
+    }
+
+    case CSS_PROP_TEXT_DECORATION:
+            // none | [ underline || overline || line-through || blink ] | inherit
+        if (id == CSS_VAL_NONE) {
+            valid_primitive = true;
+        } else {
+            CSSValueListImpl *list = new CSSValueListImpl;
+            bool is_valid = true;
+            while( is_valid && value ) {
+                switch ( value->id ) {
+                case CSS_VAL_BLINK:
+                    break;
+                case CSS_VAL_UNDERLINE:
+                case CSS_VAL_OVERLINE:
+                case CSS_VAL_LINE_THROUGH:
+                    list->append( new CSSPrimitiveValueImpl( value->id ) );
+                    break;
+                default:
+                    is_valid = false;
+                }
+                value = valueList->next();
+            }
+            //kdDebug( 6080 ) << "got " << list->length() << "d decorations" << endl;
+            if(list->length() && is_valid) {
+                parsedValue = list;
+                valueList->next();
+            } else {
+                delete list;
+            }
+        }
+        break;
+
+    case CSS_PROP_TABLE_LAYOUT:         // auto | fixed | inherit
+        if ( id == CSS_VAL_AUTO || id == CSS_VAL_FIXED )
+            valid_primitive = true;
+        break;
+
+    case CSS_PROP__KHTML_FLOW_MODE:
+        if ( id == CSS_VAL__KHTML_NORMAL || id == CSS_VAL__KHTML_AROUND_FLOATS )
+            valid_primitive = true;
+        break;
+
+    /* CSS3 properties */
+    case CSS_PROP_BOX_SIZING:        // border-box | content-box | inherit
+        if ( id == CSS_VAL_BORDER_BOX || id == CSS_VAL_CONTENT_BOX )
+            valid_primitive = true;
+        break;
+    case CSS_PROP_OUTLINE_OFFSET:
+        valid_primitive = validUnit(value, FLength, strict);
+        break;
+    case CSS_PROP_TEXT_SHADOW:  // CSS2 property, dropped in CSS2.1, back in CSS3, so treat as CSS3
+        if (id == CSS_VAL_NONE)
+            valid_primitive = true;
+        else
+            return parseShadow(propId, important);
+        break;
+    case CSS_PROP_OPACITY:
+        valid_primitive = validUnit(value, FNumber, strict);
+        break;
+    case CSS_PROP__KHTML_USER_INPUT:        // none | enabled | disabled | inherit
+        if ( id == CSS_VAL_NONE || id == CSS_VAL_ENABLED || id == CSS_VAL_DISABLED )
+            valid_primitive = true;
+//        kdDebug(6080) << "CSS_PROP__KHTML_USER_INPUT: " << valid_primitive << endl;
+        break;
+    case CSS_PROP__KHTML_MARQUEE: {
+        const int properties[5] = { CSS_PROP__KHTML_MARQUEE_DIRECTION, CSS_PROP__KHTML_MARQUEE_INCREMENT,
+                                    CSS_PROP__KHTML_MARQUEE_REPETITION,
+                                    CSS_PROP__KHTML_MARQUEE_STYLE, CSS_PROP__KHTML_MARQUEE_SPEED };
+        return parseShortHand(propId, properties, 5, important);
+    }
+    case CSS_PROP__KHTML_MARQUEE_DIRECTION:
+        if (id == CSS_VAL_FORWARDS || id == CSS_VAL_BACKWARDS || id == CSS_VAL_AHEAD ||
+            id == CSS_VAL_REVERSE || id == CSS_VAL_LEFT || id == CSS_VAL_RIGHT || id == CSS_VAL_DOWN ||
+            id == CSS_VAL_UP || id == CSS_VAL_AUTO)
+            valid_primitive = true;
+        break;
+    case CSS_PROP__KHTML_MARQUEE_INCREMENT:
+        if (id == CSS_VAL_SMALL || id == CSS_VAL_LARGE || id == CSS_VAL_MEDIUM)
+            valid_primitive = true;
+        else
+            valid_primitive = validUnit(value, FLength|FPercent, strict&(!nonCSSHint));
+        break;
+    case CSS_PROP__KHTML_MARQUEE_STYLE:
+        if (id == CSS_VAL_NONE || id == CSS_VAL_SLIDE || id == CSS_VAL_SCROLL || id == CSS_VAL_ALTERNATE ||
+            id == CSS_VAL_UNFURL)
+            valid_primitive = true;
+        break;
+    case CSS_PROP__KHTML_MARQUEE_REPETITION:
+        if (id == CSS_VAL_INFINITE)
+            valid_primitive = true;
+        else
+            valid_primitive = validUnit(value, FInteger|FNonNeg, strict&(!nonCSSHint));
+        break;
+    case CSS_PROP__KHTML_MARQUEE_SPEED:
+        if (id == CSS_VAL_NORMAL || id == CSS_VAL_SLOW || id == CSS_VAL_FAST)
+            valid_primitive = true;
+        else
+            valid_primitive = validUnit(value, FTime|FInteger|FNonNeg, strict&(!nonCSSHint));
+        break;
+    case CSS_PROP_TEXT_OVERFLOW: // clip | ellipsis
+        if (id == CSS_VAL_CLIP || id == CSS_VAL_ELLIPSIS)
+            valid_primitive = true;
+        break;
+    // End of CSS3 properties
+
+        /* shorthand properties */
+    case CSS_PROP_BACKGROUND:
+            // ['background-color' || 'background-image' ||'background-repeat' ||
+        // 'background-attachment' || 'background-position'] | inherit
+	return parseBackgroundShorthand(important);
+    case CSS_PROP_BORDER:
+         // [ 'border-width' || 'border-style' || <color> ] | inherit
+    {
+        const int properties[3] = { CSS_PROP_BORDER_WIDTH, CSS_PROP_BORDER_STYLE,
+                                    CSS_PROP_BORDER_COLOR };
+        return parseShortHand(propId, properties, 3, important);
+    }
+    case CSS_PROP_BORDER_TOP:
+            // [ 'border-top-width' || 'border-style' || <color> ] | inherit
+    {
+        const int properties[3] = { CSS_PROP_BORDER_TOP_WIDTH, CSS_PROP_BORDER_TOP_STYLE,
+                                    CSS_PROP_BORDER_TOP_COLOR};
+        return parseShortHand(propId, properties, 3, important);
+    }
+    case CSS_PROP_BORDER_RIGHT:
+            // [ 'border-right-width' || 'border-style' || <color> ] | inherit
+    {
+        const int properties[3] = { CSS_PROP_BORDER_RIGHT_WIDTH, CSS_PROP_BORDER_RIGHT_STYLE,
+                                    CSS_PROP_BORDER_RIGHT_COLOR };
+        return parseShortHand(propId, properties, 3, important);
+    }
+    case CSS_PROP_BORDER_BOTTOM:
+            // [ 'border-bottom-width' || 'border-style' || <color> ] | inherit
+    {
+        const int properties[3] = { CSS_PROP_BORDER_BOTTOM_WIDTH, CSS_PROP_BORDER_BOTTOM_STYLE,
+                                    CSS_PROP_BORDER_BOTTOM_COLOR };
+        return parseShortHand(propId, properties, 3, important);
+    }
+    case CSS_PROP_BORDER_LEFT:
+            // [ 'border-left-width' || 'border-style' || <color> ] | inherit
+    {
+        const int properties[3] = { CSS_PROP_BORDER_LEFT_WIDTH, CSS_PROP_BORDER_LEFT_STYLE,
+                                    CSS_PROP_BORDER_LEFT_COLOR };
+        return parseShortHand(propId, properties, 3, important);
+    }
+    case CSS_PROP_OUTLINE:
+            // [ 'outline-color' || 'outline-style' || 'outline-width' ] | inherit
+    {
+        const int properties[3] = { CSS_PROP_OUTLINE_WIDTH, CSS_PROP_OUTLINE_STYLE,
+                                    CSS_PROP_OUTLINE_COLOR };
+        return parseShortHand(propId, properties, 3, important);
+    }
+    case CSS_PROP_BORDER_COLOR:
+            // <color>{1,4} | inherit
+    {
+        const int properties[4] = { CSS_PROP_BORDER_TOP_COLOR, CSS_PROP_BORDER_RIGHT_COLOR,
+                                    CSS_PROP_BORDER_BOTTOM_COLOR, CSS_PROP_BORDER_LEFT_COLOR };
+        return parse4Values(propId, properties, important);
+    }
+    case CSS_PROP_BORDER_WIDTH:
+            // <border-width>{1,4} | inherit
+    {
+        const int properties[4] = { CSS_PROP_BORDER_TOP_WIDTH, CSS_PROP_BORDER_RIGHT_WIDTH,
+                                    CSS_PROP_BORDER_BOTTOM_WIDTH, CSS_PROP_BORDER_LEFT_WIDTH };
+        return parse4Values(propId, properties, important);
+    }
+    case CSS_PROP_BORDER_STYLE:
+            // <border-style>{1,4} | inherit
+    {
+        const int properties[4] = { CSS_PROP_BORDER_TOP_STYLE, CSS_PROP_BORDER_RIGHT_STYLE,
+                                    CSS_PROP_BORDER_BOTTOM_STYLE, CSS_PROP_BORDER_LEFT_STYLE };
+        return parse4Values(propId, properties, important);
+    }
+    case CSS_PROP_MARGIN:
+            // <margin-width>{1,4} | inherit
+    {
+        const int properties[4] = { CSS_PROP_MARGIN_TOP, CSS_PROP_MARGIN_RIGHT,
+                                    CSS_PROP_MARGIN_BOTTOM, CSS_PROP_MARGIN_LEFT };
+        return parse4Values(propId, properties, important);
+    }
+    case CSS_PROP_PADDING:
+            // <padding-width>{1,4} | inherit
+    {
+        const int properties[4] = { CSS_PROP_PADDING_TOP, CSS_PROP_PADDING_RIGHT,
+                                    CSS_PROP_PADDING_BOTTOM, CSS_PROP_PADDING_LEFT };
+        return parse4Values(propId, properties, important);
+    }
+    case CSS_PROP_FONT:
+            // [ [ 'font-style' || 'font-variant' || 'font-weight' ]? 'font-size' [ / 'line-height' ]?
+        // 'font-family' ] | caption | icon | menu | message-box | small-caption | status-bar | inherit
+        if ( id >= CSS_VAL_CAPTION && id <= CSS_VAL_STATUS_BAR )
+            valid_primitive = true;
+        else
+            return parseFont(important);
+
+    case CSS_PROP_LIST_STYLE:
+    {
+        const int properties[3] = { CSS_PROP_LIST_STYLE_TYPE, CSS_PROP_LIST_STYLE_POSITION,
+                                    CSS_PROP_LIST_STYLE_IMAGE };
+        return parseShortHand(propId, properties, 3, important);
+    }
+    case CSS_PROP_WORD_WRAP:
+    {
+        // normal | break-word
+        if ( id == CSS_VAL_NORMAL || id == CSS_VAL_BREAK_WORD )
+            valid_primitive = true;
+        break;
+    }
+    default:
+// #ifdef CSS_DEBUG
+//         kdDebug( 6080 ) << "illegal or CSS2 Aural property: " << val << endl;
+// #endif
+        break;
+    }
+
+    if ( valid_primitive ) {
+
+        if ( id != 0 ) {
+            parsedValue = new CSSPrimitiveValueImpl( id );
+        } else if ( value->unit == CSSPrimitiveValue::CSS_STRING )
+            parsedValue = new CSSPrimitiveValueImpl( domString( value->string ),
+                                                     (CSSPrimitiveValue::UnitTypes) value->unit );
+        else if ( value->unit >= CSSPrimitiveValue::CSS_NUMBER &&
+                  value->unit <= CSSPrimitiveValue::CSS_KHZ ) {
+            parsedValue = new CSSPrimitiveValueImpl( value->fValue,
+                                                     (CSSPrimitiveValue::UnitTypes) value->unit );
+        } else if ( value->unit >= Value::Q_EMS ) {
+            parsedValue = new CSSQuirkPrimitiveValueImpl( value->fValue, CSSPrimitiveValue::CSS_EMS );
+        }
+        valueList->next();
+    }
+    if ( parsedValue ) {
+        if (!valueList->current() || inShorthand()) {
+            addProperty( propId, parsedValue, important );
+            return true;
+        }
+        delete parsedValue;
+    }
+    return false;
+}
+
+void CSSParser::addBackgroundValue(CSSValueImpl*& lval, CSSValueImpl* rval)
+{
+    if (lval) {
+        if (lval->isValueList())
+            static_cast<CSSValueListImpl*>(lval)->append(rval);
+        else {
+            CSSValueImpl* oldVal = lval;
+            CSSValueListImpl* list = new CSSValueListImpl();
+            lval = list;
+            list->append(oldVal);
+            list->append(rval);
+        }
+    }
+    else
+        lval = rval;
+}
+
+bool CSSParser::parseBackgroundShorthand(bool important)
+{
+    // Position must come before color in this array because a plain old "0" is a legal color
+    // in quirks mode but it's usually the X coordinate of a position.
+    // FIXME: Add CSS_PROP__KHTML_BACKGROUND_SIZE to the shorthand.
+    const int numProperties = 7;
+    const int properties[numProperties] = { CSS_PROP_BACKGROUND_IMAGE, CSS_PROP_BACKGROUND_REPEAT,
+        CSS_PROP_BACKGROUND_ATTACHMENT, CSS_PROP_BACKGROUND_POSITION,  CSS_PROP__KHTML_BACKGROUND_CLIP,
+        CSS_PROP__KHTML_BACKGROUND_ORIGIN, CSS_PROP_BACKGROUND_COLOR };
+
+    ShorthandScope scope(this, CSS_PROP_BACKGROUND);
+
+    bool parsedProperty[numProperties] = { false }; // compiler will repeat false as necessary
+    CSSValueImpl* values[numProperties] = { 0 }; // compiler will repeat 0 as necessary
+    CSSValueImpl* positionYValue = 0;
+    int i;
+
+    while (valueList->current()) {
+        Value* val = valueList->current();
+        if (val->unit == Value::Operator && val->iValue == ',') {
+            // We hit the end.  Fill in all remaining values with the initial value.
+            valueList->next();
+            for (i = 0; i < numProperties; ++i) {
+                if (properties[i] == CSS_PROP_BACKGROUND_COLOR && parsedProperty[i])
+                    // Color is not allowed except as the last item in a list.  Reject the entire
+                    // property.
+                    goto fail;
+
+                if (!parsedProperty[i] && properties[i] != CSS_PROP_BACKGROUND_COLOR) {
+                    addBackgroundValue(values[i], new CSSInitialValueImpl());
+                    if (properties[i] == CSS_PROP_BACKGROUND_POSITION)
+                        addBackgroundValue(positionYValue, new CSSInitialValueImpl());
+                }
+                parsedProperty[i] = false;
+            }
+            if (!valueList->current())
+                break;
+        }
+
+        bool found = false;
+        for (i = 0; !found && i < numProperties; ++i) {
+            if (!parsedProperty[i]) {
+                CSSValueImpl *val1 = 0, *val2 = 0;
+                int propId1, propId2;
+		if (parseBackgroundProperty(properties[i], propId1, propId2, val1, val2)) {
+		    parsedProperty[i] = found = true;
+                    addBackgroundValue(values[i], val1);
+                    if (properties[i] == CSS_PROP_BACKGROUND_POSITION)
+                        addBackgroundValue(positionYValue, val2);
+		}
+	    }
+	}
+
+        // if we didn't find at least one match, this is an
+        // invalid shorthand and we have to ignore it
+        if (!found)
+            goto fail;
+    }
+
+    // Fill in any remaining properties with the initial value.
+    for (i = 0; i < numProperties; ++i) {
+        if (!parsedProperty[i]) {
+            addBackgroundValue(values[i], new CSSInitialValueImpl());
+            if (properties[i] == CSS_PROP_BACKGROUND_POSITION)
+                addBackgroundValue(positionYValue, new CSSInitialValueImpl());
+        }
+    }
+
+    // Now add all of the properties we found.
+    for (i = 0; i < numProperties; i++) {
+        if (properties[i] == CSS_PROP_BACKGROUND_POSITION) {
+            addProperty(CSS_PROP_BACKGROUND_POSITION_X, values[i], important);
+            addProperty(CSS_PROP_BACKGROUND_POSITION_Y, positionYValue, important);
+        }
+        else
+            addProperty(properties[i], values[i], important);
+    }
+
+    return true;
+
+fail:
+    for (int k = 0; k < numProperties; k++)
+        delete values[k];
+    delete positionYValue;
+    return false;
+}
+
+bool CSSParser::parseShortHand(int propId, const int *properties, int numProperties, bool important )
+{
+    /* We try to match as many properties as possible
+     * We setup an array of booleans to mark which property has been found,
+     * and we try to search for properties until it makes no longer any sense
+     */
+    ShorthandScope scope(this, propId);
+
+    bool found = false;
+    bool fnd[6]; //Trust me ;)
+    for( int i = 0; i < numProperties; i++ )
+        fnd[i] = false;
+
+    while ( valueList->current() ) {
+        found = false;
+        for (int propIndex = 0; !found && propIndex < numProperties; ++propIndex) {
+            if (!fnd[propIndex]) {
+                if ( parseValue( properties[propIndex], important ) ) {
+                    fnd[propIndex] = found = true;
+                }
+            }
+        }
+
+        // if we didn't find at least one match, this is an
+        // invalid shorthand and we have to ignore it
+        if (!found)
+            return false;
+    }
+
+    // Fill in any remaining properties with the initial value.
+    m_implicitShorthand = true;
+    for (int i = 0; i < numProperties; ++i) {
+        if (!fnd[i])
+            addProperty(properties[i], new CSSInitialValueImpl(), important);
+    }
+    m_implicitShorthand = false;
+
+    return true;
+}
+
+bool CSSParser::parse4Values(int propId, const int *properties,  bool important )
+{
+    /* From the CSS 2 specs, 8.3
+     * If there is only one value, it applies to all sides. If there are two values, the top and
+     * bottom margins are set to the first value and the right and left margins are set to the second.
+     * If there are three values, the top is set to the first value, the left and right are set to the
+     * second, and the bottom is set to the third. If there are four values, they apply to the top,
+     * right, bottom, and left, respectively.
+     */
+
+    int num = inShorthand() ? 1 : valueList->size();
+    //tqDebug("parse4Values: num=%d %d", num,  valueList->numValues );
+
+    ShorthandScope scope(this, propId);
+
+    // the order is top, right, bottom, left
+    switch (num) {
+        case 1: {
+            if (!parseValue(properties[0], important))
+                return false;
+            CSSValueImpl *value = parsedProperties[numParsedProperties-1]->value();
+            m_implicitShorthand = true;
+            addProperty(properties[1], value, important);
+            addProperty(properties[2], value, important);
+            addProperty(properties[3], value, important);
+            m_implicitShorthand = false;
+            break;
+        }
+        case 2: {
+            if (!parseValue(properties[0], important) || !parseValue(properties[1], important))
+                return false;
+            CSSValueImpl *value = parsedProperties[numParsedProperties-2]->value();
+            m_implicitShorthand = true;
+            addProperty(properties[2], value, important);
+            value = parsedProperties[numParsedProperties-2]->value();
+            addProperty(properties[3], value, important);
+            m_implicitShorthand = false;
+            break;
+        }
+        case 3: {
+            if (!parseValue(properties[0], important) || !parseValue(properties[1], important) || !parseValue(properties[2], important))
+                return false;
+            CSSValueImpl *value = parsedProperties[numParsedProperties-2]->value();
+            m_implicitShorthand = true;
+            addProperty(properties[3], value, important);
+            m_implicitShorthand = false;
+            break;
+        }
+        case 4: {
+            if (!parseValue(properties[0], important) || !parseValue(properties[1], important) ||
+                !parseValue(properties[2], important) || !parseValue(properties[3], important))
+                return false;
+            break;
+        }
+        default: {
+            return false;
+        }
+    }
+
+    return true;
+}
+
+// [ <string> | <uri> | <counter> | attr(X) | open-quote | close-quote | no-open-quote | no-close-quote ]+ | inherit
+// in CSS 2.1 this got somewhat reduced:
+// [ <string> | attr(X) | open-quote | close-quote | no-open-quote | no-close-quote ]+ | inherit
+bool CSSParser::parseContent( int propId, bool important )
+{
+    CSSValueListImpl* values = new CSSValueListImpl();
+
+    bool isValid = true;
+    Value *val;
+    CSSValueImpl *parsedValue = 0;
+    while ( (val = valueList->current()) ) {
+        parsedValue = 0;
+        if ( val->unit == CSSPrimitiveValue::CSS_URI ) {
+            // url
+            DOMString value = tdehtml::parseURL(domString(val->string));
+            parsedValue = new CSSImageValueImpl(
+                DOMString(KURL( styleElement->baseURL(), value.string()).url() ), styleElement );
+#ifdef CSS_DEBUG
+            kdDebug( 6080 ) << "content, url=" << value.string() << " base=" << styleElement->baseURL().url( ) << endl;
+#endif
+        } else if ( val->unit == Value::Function ) {
+            // attr( X ) | counter( X [,Y] ) | counters( X, Y, [,Z] )
+            ValueList *args = val->function->args;
+            TQString fname = qString( val->function->name ).lower();
+            if (!args) return false;
+            if (fname == "attr(") {
+                if ( args->size() != 1)
+                    return false;
+                Value *a = args->current();
+                if (a->unit != CSSPrimitiveValue::CSS_IDENT) {
+                    isValid=false;
+                    break;
+                }
+                if (qString(a->string)[0] == '-') {
+                    isValid=false;
+                    break;
+                }
+                parsedValue = new CSSPrimitiveValueImpl(domString(a->string), CSSPrimitiveValue::CSS_ATTR);
+            }
+            else
+            if (fname == "counter(") {
+                parsedValue = parseCounterContent(args, false);
+                if (!parsedValue) return false;
+            } else
+            if (fname == "counters(") {
+                parsedValue = parseCounterContent(args, true);
+                if (!parsedValue) return false;
+            }
+            else
+                return false;
+
+        } else if ( val->unit == CSSPrimitiveValue::CSS_IDENT ) {
+            // open-quote | close-quote | no-open-quote | no-close-quote
+            if ( val->id == CSS_VAL_OPEN_QUOTE ||
+                 val->id == CSS_VAL_CLOSE_QUOTE ||
+                 val->id == CSS_VAL_NO_OPEN_QUOTE ||
+                 val->id == CSS_VAL_NO_CLOSE_QUOTE ) {
+                parsedValue = new CSSPrimitiveValueImpl(val->id);
+            }
+        } else if ( val->unit == CSSPrimitiveValue::CSS_STRING ) {
+            parsedValue = new CSSPrimitiveValueImpl(domString(val->string), CSSPrimitiveValue::CSS_STRING);
+        }
+
+        if (parsedValue)
+            values->append(parsedValue);
+        else {
+            isValid = false;
+            break;
+        }
+        valueList->next();
+    }
+    if ( isValid && values->length() ) {
+        addProperty( propId, values, important );
+        valueList->next();
+        return true;
+    }
+
+    delete values;  // also frees any content by deref
+    return false;
+}
+
+CSSValueImpl* CSSParser::parseCounterContent(ValueList *args, bool counters)
+{
+    if (counters || (args->size() != 1 && args->size() != 3))
+        if (!counters || (args->size() != 3 && args->size() != 5))
+            return 0;
+
+    CounterImpl *counter = new CounterImpl;
+    Value *i = args->current();
+    if (i->unit != CSSPrimitiveValue::CSS_IDENT) goto invalid;
+    if (qString(i->string)[0] == '-') goto invalid;
+    counter->m_identifier = domString(i->string);
+    if (counters) {
+        i = args->next();
+        if (i->unit != Value::Operator || i->iValue != ',') goto invalid;
+        i = args->next();
+        if (i->unit != CSSPrimitiveValue::CSS_STRING) goto invalid;
+        counter->m_separator = domString(i->string);
+    }
+    counter->m_listStyle = CSS_VAL_DECIMAL - CSS_VAL_DISC;
+    i = args->next();
+    if (i) {
+        if (i->unit != Value::Operator || i->iValue != ',') goto invalid;
+        i = args->next();
+        if (i->unit != CSSPrimitiveValue::CSS_IDENT) goto invalid;
+        if (i->id < CSS_VAL_DISC || i->id > CSS_VAL__KHTML_CLOSE_QUOTE) goto invalid;
+        counter->m_listStyle = i->id - CSS_VAL_DISC;
+    }
+    return new CSSPrimitiveValueImpl(counter);
+invalid:
+    delete counter;
+    return 0;
+}
+
+CSSValueImpl* CSSParser::parseBackgroundColor()
+{
+    int id = valueList->current()->id;
+    if (id == CSS_VAL__KHTML_TEXT || id == CSS_VAL_TRANSPARENT ||
+        (id >= CSS_VAL_AQUA && id <= CSS_VAL_WINDOWTEXT) || id == CSS_VAL_MENU ||
+        (id >= CSS_VAL_GREY && id < CSS_VAL__KHTML_TEXT && !strict))
+       return new CSSPrimitiveValueImpl(id);
+    return parseColor();
+}
+
+CSSValueImpl* CSSParser::parseBackgroundImage()
+{
+    if (valueList->current()->id == CSS_VAL_NONE)
+        return new CSSImageValueImpl();
+    if (valueList->current()->unit == CSSPrimitiveValue::CSS_URI) {
+        DOMString uri = tdehtml::parseURL(domString(valueList->current()->string));
+        if (!uri.isEmpty())
+            return new CSSImageValueImpl(DOMString(KURL(styleElement->baseURL(), uri.string()).url()),
+                                         styleElement);
+    }
+    return 0;
+}
+
+CSSValueImpl* CSSParser::parseBackgroundPositionXY(bool& xFound, bool& yFound)
+{
+    int id = valueList->current()->id;
+    if (id == CSS_VAL_LEFT || id == CSS_VAL_TOP || id == CSS_VAL_RIGHT || id == CSS_VAL_BOTTOM || id == CSS_VAL_CENTER) {
+        int percent = 0;
+        if (id == CSS_VAL_LEFT || id == CSS_VAL_RIGHT) {
+            if (xFound)
+                return 0;
+            xFound = true;
+            if (id == CSS_VAL_RIGHT)
+                percent = 100;
+        }
+        else if (id == CSS_VAL_TOP || id == CSS_VAL_BOTTOM) {
+            if (yFound)
+                return 0;
+            yFound = true;
+            if (id == CSS_VAL_BOTTOM)
+                percent = 100;
+        }
+        else if (id == CSS_VAL_CENTER)
+            // Center is ambiguous, so we're not sure which position we've found yet, an x or a y.
+            percent = 50;
+        return new CSSPrimitiveValueImpl(percent, CSSPrimitiveValue::CSS_PERCENTAGE);
+    }
+    if (validUnit(valueList->current(), FPercent|FLength, strict))
+        return new CSSPrimitiveValueImpl(valueList->current()->fValue,
+                                         (CSSPrimitiveValue::UnitTypes)valueList->current()->unit);
+
+    return 0;
+}
+
+void CSSParser::parseBackgroundPosition(CSSValueImpl*& value1, CSSValueImpl*& value2)
+{
+    value1 = value2 = 0;
+    Value* value = valueList->current();
+
+    // Parse the first value.  We're just making sure that it is one of the valid keywords or a percentage/length.
+    bool value1IsX = false, value1IsY = false;
+    value1 = parseBackgroundPositionXY(value1IsX, value1IsY);
+    if (!value1)
+        return;
+
+    // It only takes one value for background-position to be correctly parsed if it was specified in a shorthand (since we
+    // can assume that any other values belong to the rest of the shorthand).  If we're not parsing a shorthand, though, the
+    // value was explicitly specified for our property.
+    value = valueList->next();
+
+    // First check for the comma.  If so, we are finished parsing this value or value pair.
+    if (value && value->unit == Value::Operator && value->iValue == ',')
+        value = 0;
+
+    bool value2IsX = false, value2IsY = false;
+    if (value) {
+        value2 = parseBackgroundPositionXY(value2IsX, value2IsY);
+        if (value2)
+            valueList->next();
+        else {
+            if (!inShorthand()) {
+                delete value1;
+                value1 = 0;
+                return;
+            }
+        }
+    }
+
+    if (!value2)
+        // Only one value was specified.  If that value was not a keyword, then it sets the x position, and the y position
+        // is simply 50%.  This is our default.
+        // For keywords, the keyword was either an x-keyword (left/right), a y-keyword (top/bottom), or an ambiguous keyword (center).
+        // For left/right/center, the default of 50% in the y is still correct.
+        value2 = new CSSPrimitiveValueImpl(50, CSSPrimitiveValue::CSS_PERCENTAGE);
+
+    if (value1IsY || value2IsX) {
+        // Swap our two values.
+        CSSValueImpl* val = value2;
+        value2 = value1;
+        value1 = val;
+    }
+}
+
+CSSValueImpl* CSSParser::parseBackgroundSize()
+{
+    Value* value = valueList->current();
+    CSSPrimitiveValueImpl* parsedValue1;
+
+    if (value->id == CSS_VAL_AUTO)
+        parsedValue1 = new CSSPrimitiveValueImpl(0, CSSPrimitiveValue::CSS_UNKNOWN);
+    else {
+        if (!validUnit(value, FLength|FPercent, strict))
+            return 0;
+        parsedValue1 = new CSSPrimitiveValueImpl(value->fValue, (CSSPrimitiveValue::UnitTypes)value->unit);
+    }
+
+    CSSPrimitiveValueImpl* parsedValue2 = parsedValue1;
+    if ((value = valueList->next())) {
+        if (value->id == CSS_VAL_AUTO)
+            parsedValue2 = new CSSPrimitiveValueImpl(0, CSSPrimitiveValue::CSS_UNKNOWN);
+        else {
+            if (!validUnit(value, FLength|FPercent, strict)) {
+                delete parsedValue1;
+                return 0;
+            }
+            parsedValue2 = new CSSPrimitiveValueImpl(value->fValue, (CSSPrimitiveValue::UnitTypes)value->unit);
+        }
+    }
+
+    PairImpl* pair = new PairImpl(parsedValue1, parsedValue2);
+    return new CSSPrimitiveValueImpl(pair);
+}
+
+bool CSSParser::parseBackgroundProperty(int propId, int& propId1, int& propId2,
+                                        CSSValueImpl*& retValue1, CSSValueImpl*& retValue2)
+{
+#ifdef CSS_DEBUG
+    kdDebug(6080) << "parseBackgroundProperty()" << endl;
+    kdDebug(6080) << "LOOKING FOR: " << getPropertyName(propId).string() << endl;
+#endif
+    CSSValueListImpl *values = 0, *values2 = 0;
+    Value* val;
+    CSSValueImpl *value = 0, *value2 = 0;
+    bool allowComma = false;
+
+    retValue1 = retValue2 = 0;
+    propId1 = propId;
+    propId2 = propId;
+    if (propId == CSS_PROP_BACKGROUND_POSITION) {
+        propId1 = CSS_PROP_BACKGROUND_POSITION_X;
+        propId2 = CSS_PROP_BACKGROUND_POSITION_Y;
+    }
+
+    while ((val = valueList->current())) {
+        CSSValueImpl *currValue = 0, *currValue2 = 0;
+        if (allowComma) {
+            if (val->unit != Value::Operator || val->iValue != ',')
+                goto failed;
+            valueList->next();
+            allowComma = false;
+        }
+        else {
+            switch (propId) {
+                case CSS_PROP_BACKGROUND_ATTACHMENT:
+                    if (val->id == CSS_VAL_SCROLL || val->id == CSS_VAL_FIXED) {
+                        currValue = new CSSPrimitiveValueImpl(val->id);
+                        valueList->next();
+                    }
+                    break;
+                case CSS_PROP_BACKGROUND_COLOR:
+                    currValue = parseBackgroundColor();
+                    if (currValue)
+                        valueList->next();
+                    break;
+                case CSS_PROP_BACKGROUND_IMAGE:
+                    currValue = parseBackgroundImage();
+                    if (currValue)
+                        valueList->next();
+                    break;
+                case CSS_PROP__KHTML_BACKGROUND_CLIP:
+                case CSS_PROP__KHTML_BACKGROUND_ORIGIN:
+                    if (val->id == CSS_VAL_BORDER || val->id == CSS_VAL_PADDING || val->id == CSS_VAL_CONTENT) {
+                        currValue = new CSSPrimitiveValueImpl(val->id);
+                        valueList->next();
+                    }
+                    break;
+                case CSS_PROP_BACKGROUND_POSITION:
+                    parseBackgroundPosition(currValue, currValue2);
+                    // unlike the other functions, parseBackgroundPosition advances the valueList pointer
+                    break;
+                case CSS_PROP_BACKGROUND_POSITION_X: {
+                    bool xFound = false, yFound = true;
+                    currValue = parseBackgroundPositionXY(xFound, yFound);
+                    if (currValue)
+                        valueList->next();
+                    break;
+                }
+                case CSS_PROP_BACKGROUND_POSITION_Y: {
+                    bool xFound = true, yFound = false;
+                    currValue = parseBackgroundPositionXY(xFound, yFound);
+                    if (currValue)
+                        valueList->next();
+                    break;
+                }
+                case CSS_PROP_BACKGROUND_REPEAT:
+                    if (val->id >= CSS_VAL_REPEAT && val->id <= CSS_VAL_NO_REPEAT) {
+                        currValue = new CSSPrimitiveValueImpl(val->id);
+                        valueList->next();
+                    }
+                    break;
+                case CSS_PROP__KHTML_BACKGROUND_SIZE:
+                    currValue = parseBackgroundSize();
+                    if (currValue)
+                        valueList->next();
+                    break;
+            }
+
+            if (!currValue)
+                goto failed;
+
+            if (value && !values) {
+                values = new CSSValueListImpl();
+                values->append(value);
+                value = 0;
+            }
+
+            if (value2 && !values2) {
+                values2 = new CSSValueListImpl();
+                values2->append(value2);
+                value2 = 0;
+            }
+
+            if (values)
+                values->append(currValue);
+            else
+                value = currValue;
+            if (currValue2) {
+                if (values2)
+                    values2->append(currValue2);
+                else
+                    value2 = currValue2;
+            }
+            allowComma = true;
+        }
+
+        // When parsing the 'background' shorthand property, we let it handle building up the lists for all
+        // properties.
+        if (inShorthand())
+            break;
+    }
+
+    if (values && values->length()) {
+        retValue1 = values;
+        if (values2 && values2->length())
+            retValue2 = values2;
+        return true;
+    }
+    if (value) {
+        retValue1 = value;
+        retValue2 = value2;
+        return true;
+    }
+
+failed:
+    delete values; delete values2;
+    delete value; delete value2;
+    return false;
+}
+
+bool CSSParser::parseShape( int propId, bool important )
+{
+    Value *value = valueList->current();
+    ValueList *args = value->function->args;
+    TQString fname = qString( value->function->name ).lower();
+    //tqDebug( "parseShape: fname: %d", fname.latin1() );
+    if ( fname != "rect(" || !args )
+        return false;
+
+    // rect( t, r, b, l ) || rect( t r b l )
+    if ( args->size() != 4 && args->size() != 7 )
+        return false;
+    RectImpl *rect = new RectImpl();
+    bool valid = true;
+    int i = 0;
+    Value *a = args->current();
+    while ( a ) {
+        valid = validUnit( a, FLength, strict );
+        if ( !valid )
+            break;
+        CSSPrimitiveValueImpl *length =
+            new CSSPrimitiveValueImpl( a->fValue, (CSSPrimitiveValue::UnitTypes) a->unit );
+        if ( i == 0 )
+            rect->setTop( length );
+        else if ( i == 1 )
+            rect->setRight( length );
+        else if ( i == 2 )
+            rect->setBottom( length );
+        else
+            rect->setLeft( length );
+        a = args->next();
+        if ( a && args->size() == 7 ) {
+            if ( a->unit == Value::Operator && a->iValue == ',' ) {
+                a = args->next();
+            } else {
+                valid = false;
+                break;
+            }
+        }
+        i++;
+    }
+    if ( valid ) {
+        addProperty( propId, new CSSPrimitiveValueImpl( rect ), important );
+        valueList->next();
+        return true;
+    }
+    delete rect;
+    return false;
+}
+
+// [ 'font-style' || 'font-variant' || 'font-weight' ]? 'font-size' [ / 'line-height' ]? 'font-family'
+bool CSSParser::parseFont( bool important )
+{
+//     kdDebug(6080) << "parsing font property current=" << valueList->currentValue << endl;
+    bool valid = true;
+    Value *value = valueList->current();
+    CSSValueListImpl* family = 0;
+    CSSPrimitiveValueImpl *style = 0, *variant = 0, *weight = 0, *size = 0, *lineHeight = 0;
+    // optional font-style, font-variant and font-weight
+    while ( value ) {
+//         kdDebug( 6080 ) << "got value " << value->id << " / " << (value->unit == CSSPrimitiveValue::CSS_STRING ||
+        //                                    value->unit == CSSPrimitiveValue::CSS_IDENT ? qString( value->string ) : TQString::null )
+//                         << endl;
+        int id = value->id;
+        if ( id ) {
+            if ( id == CSS_VAL_NORMAL ) {
+                // do nothing, it's the initial value for all three
+            }
+            /*
+              else if ( id == CSS_VAL_INHERIT ) {
+              // set all non set ones to inherit
+              // This is not that simple as the inherit could also apply to the following font-size.
+              // very ahrd to tell without looking ahead.
+              inherit = true;
+                } */
+            else if ( id == CSS_VAL_ITALIC || id == CSS_VAL_OBLIQUE ) {
+                if ( style )
+                    goto invalid;
+                style = new CSSPrimitiveValueImpl( id );
+            } else if ( id == CSS_VAL_SMALL_CAPS ) {
+                if ( variant )
+                    goto invalid;
+                variant = new CSSPrimitiveValueImpl( id );
+            } else if ( id >= CSS_VAL_BOLD && id <= CSS_VAL_LIGHTER ) {
+                if ( weight )
+                    goto invalid;
+                weight = new CSSPrimitiveValueImpl( id );
+            } else {
+                valid = false;
+            }
+        } else if ( !weight && validUnit( value, FInteger|FNonNeg, true ) ) {
+            int w = (int)value->fValue;
+            int val = 0;
+            if ( w == 100 )
+                val = CSS_VAL_100;
+            else if ( w == 200 )
+                val = CSS_VAL_200;
+            else if ( w == 300 )
+                val = CSS_VAL_300;
+            else if ( w == 400 )
+                val = CSS_VAL_400;
+            else if ( w == 500 )
+                val = CSS_VAL_500;
+            else if ( w == 600 )
+                val = CSS_VAL_600;
+            else if ( w == 700 )
+                val = CSS_VAL_700;
+            else if ( w == 800 )
+                val = CSS_VAL_800;
+            else if ( w == 900 )
+                val = CSS_VAL_900;
+
+            if ( val )
+                weight = new CSSPrimitiveValueImpl( val );
+            else
+                valid = false;
+        } else {
+            valid = false;
+        }
+        if ( !valid )
+            break;
+        value = valueList->next();
+    }
+    if ( !value )
+        goto invalid;
+
+    // set undefined values to default
+    if ( !style )
+        style = new CSSPrimitiveValueImpl( CSS_VAL_NORMAL );
+    if ( !variant )
+        variant = new CSSPrimitiveValueImpl( CSS_VAL_NORMAL );
+    if ( !weight )
+        weight = new CSSPrimitiveValueImpl( CSS_VAL_NORMAL );
+
+//     kdDebug( 6080 ) << "  got style, variant and weight current=" << valueList->currentValue << endl;
+
+    // now a font size _must_ come
+    // <absolute-size> | <relative-size> | <length> | <percentage> | inherit
+    if ( value->id >= CSS_VAL_XX_SMALL && value->id <= CSS_VAL_LARGER )
+        size = new CSSPrimitiveValueImpl( value->id );
+    else if ( validUnit( value, FLength|FPercent, strict ) ) {
+        size = new CSSPrimitiveValueImpl( value->fValue, (CSSPrimitiveValue::UnitTypes) value->unit );
+    }
+    value = valueList->next();
+    if ( !size || !value )
+        goto invalid;
+
+    // kdDebug( 6080 ) << "  got size" << endl;
+
+    if ( value->unit == Value::Operator && value->iValue == '/' ) {
+        // line-height
+        value = valueList->next();
+        if ( !value )
+            goto invalid;
+        if ( value->id == CSS_VAL_NORMAL ) {
+            // default value, nothing to do
+        } else if ( validUnit( value, FNumber|FLength|FPercent, strict ) ) {
+            lineHeight = new CSSPrimitiveValueImpl( value->fValue, (CSSPrimitiveValue::UnitTypes) value->unit );
+        } else {
+            goto invalid;
+        }
+        value = valueList->next();
+        if ( !value )
+            goto invalid;
+    }
+    if ( !lineHeight )
+        lineHeight = new CSSPrimitiveValueImpl( CSS_VAL_NORMAL );
+
+//     kdDebug( 6080 ) << "  got line height current=" << valueList->currentValue << endl;
+    // font family must come now
+    family = parseFontFamily();
+
+    if ( valueList->current() || !family )
+        goto invalid;
+    //kdDebug( 6080 ) << "  got family, parsing ok!" << endl;
+
+    addProperty( CSS_PROP_FONT_FAMILY,  family,     important );
+    addProperty( CSS_PROP_FONT_STYLE,   style,      important );
+    addProperty( CSS_PROP_FONT_VARIANT, variant,    important );
+    addProperty( CSS_PROP_FONT_WEIGHT,  weight,     important );
+    addProperty( CSS_PROP_FONT_SIZE,    size,       important );
+    addProperty( CSS_PROP_LINE_HEIGHT,  lineHeight, important );
+    return true;
+
+ invalid:
+    //kdDebug(6080) << "   -> invalid" << endl;
+    delete family;
+    delete style;
+    delete variant;
+    delete weight;
+    delete size;
+    delete lineHeight;
+
+    return false;
+}
+
+CSSValueListImpl *CSSParser::parseFontFamily()
+{
+//     kdDebug( 6080 ) << "CSSParser::parseFontFamily current=" << valueList->currentValue << endl;
+    CSSValueListImpl *list = new CSSValueListImpl;
+    Value *value = valueList->current();
+    TQString currFace;
+
+    while ( value ) {
+//         kdDebug( 6080 ) << "got value " << value->id << " / "
+//                         << (value->unit == CSSPrimitiveValue::CSS_STRING ||
+//                             value->unit == CSSPrimitiveValue::CSS_IDENT ? qString( value->string ) : TQString::null )
+//                         << endl;
+        Value* nextValue = valueList->next();
+        bool nextValBreaksFont = !nextValue ||
+                                 (nextValue->unit == Value::Operator && nextValue->iValue == ',');
+        bool nextValIsFontName = nextValue &&
+                                 ((nextValue->id >= CSS_VAL_SERIF && nextValue->id <= CSS_VAL_MONOSPACE) ||
+                                  (nextValue->unit == CSSPrimitiveValue::CSS_STRING ||
+                                   nextValue->unit == CSSPrimitiveValue::CSS_IDENT));
+
+        if (value->id >= CSS_VAL_SERIF && value->id <= CSS_VAL_MONOSPACE) {
+            if (!currFace.isNull()) {
+                currFace += ' ';
+                currFace += qString(value->string);
+            }
+            else if (nextValBreaksFont || !nextValIsFontName) {
+                if ( !currFace.isNull() ) {
+                    list->append( new FontFamilyValueImpl( currFace ) );
+                    currFace = TQString::null;
+                }
+                list->append(new CSSPrimitiveValueImpl(value->id));
+            }
+            else {
+                currFace = qString( value->string );
+            }
+        }
+        else if (value->unit == CSSPrimitiveValue::CSS_STRING) {
+            // Strings never share in a family name.
+            currFace = TQString::null;
+            list->append(new FontFamilyValueImpl(qString( value->string) ) );
+        }
+        else if (value->unit == CSSPrimitiveValue::CSS_IDENT) {
+            if (!currFace.isNull()) {
+                currFace += ' ';
+                currFace += qString(value->string);
+            }
+            else if (nextValBreaksFont || !nextValIsFontName) {
+                if ( !currFace.isNull() ) {
+                    list->append( new FontFamilyValueImpl( currFace ) );
+                    currFace = TQString::null;
+                }
+                list->append(new FontFamilyValueImpl( qString( value->string ) ) );
+        }
+        else {
+                currFace = qString( value->string);
+        }
+        }
+	else {
+ 	    //kdDebug( 6080 ) << "invalid family part" << endl;
+            break;
+        }
+
+        if (!nextValue)
+            break;
+
+        if (nextValBreaksFont) {
+        value = valueList->next();
+            if ( !currFace.isNull() )
+                list->append( new FontFamilyValueImpl( currFace ) );
+            currFace = TQString::null;
+        }
+        else if (nextValIsFontName)
+            value = nextValue;
+        else
+            break;
+    }
+
+    if ( !currFace.isNull() )
+        list->append( new FontFamilyValueImpl( currFace ) );
+
+    if ( !list->length() ) {
+        delete list;
+        list = 0;
+    }
+    return list;
+}
+
+ 
+bool CSSParser::parseColorParameters(Value* value, int* colorArray, bool parseAlpha)
+{
+    ValueList* args = value->function->args;
+    Value* v = args->current();
+    // Get the first value
+    if (!validUnit(v, FInteger | FPercent, true))
+        return false;
+    colorArray[0] = static_cast<int>(v->fValue * (v->unit == CSSPrimitiveValue::CSS_PERCENTAGE ? 256.0 / 100.0 : 1.0));
+    for (int i = 1; i < 3; i++) {
+        v = args->next();
+        if (v->unit != Value::Operator && v->iValue != ',')
+            return false;
+        v = args->next();
+        if (!validUnit(v, FInteger | FPercent, true))
+            return false;
+        colorArray[i] = static_cast<int>(v->fValue * (v->unit == CSSPrimitiveValue::CSS_PERCENTAGE ? 256.0 / 100.0 : 1.0));
+    }
+    if (parseAlpha) {
+        v = args->next();
+        if (v->unit != Value::Operator && v->iValue != ',')
+            return false;
+        v = args->next();
+        if (!validUnit(v, FNumber, true))
+            return false;
+        colorArray[3] = static_cast<int>(kMax(0.0, kMin(1.0, v->fValue)) * 255);
+    }
+    return true;
+}
+ 
+// CSS3 specification defines the format of a HSL color as
+// hsl(<number>, <percent>, <percent>)
+// and with alpha, the format is
+// hsla(<number>, <percent>, <percent>, <number>)
+// The first value, HUE, is in an angle with a value between 0 and 360
+bool CSSParser::parseHSLParameters(Value* value, double* colorArray, bool parseAlpha)
+{
+    ValueList* args = value->function->args;
+    Value* v = args->current();
+    // Get the first value
+    if (!validUnit(v, FInteger, true))
+        return false;
+    // normalize the Hue value and change it to be between 0 and 1.0
+    colorArray[0] = (((static_cast<int>(v->fValue) % 360) + 360) % 360) / 360.0;
+    for (int i = 1; i < 3; i++) {
+        v = args->next();
+        if (v->unit != Value::Operator && v->iValue != ',')
+            return false;
+        v = args->next();
+        if (!validUnit(v, FPercent, true))
+            return false;
+        colorArray[i] = kMax(0.0, kMin(100.0, v->fValue)) / 100.0; // needs to be value between 0 and 1.0
+    }
+    if (parseAlpha) {
+        v = args->next();
+        if (v->unit != Value::Operator && v->iValue != ',')
+            return false;
+        v = args->next();
+        if (!validUnit(v, FNumber, true))
+            return false;
+        colorArray[3] = kMax(0.0, kMin(1.0, v->fValue));
+    }
+    return true;
+}
+
+static bool parseColor(int unit, const TQString &name, QRgb& rgb)
+{
+    int len = name.length();
+
+    if ( !len )
+        return false;
+
+
+    bool ok;
+
+    if ( len == 3 || len == 6 ) {
+        int val = name.toInt(&ok, 16);
+        if ( ok ) {
+            if (len == 6) {
+                rgb = (0xff << 24) | val;
+                return true;
+            }
+            else if ( len == 3 ) {
+                // #abc converts to #aabbcc according to the specs
+                rgb = (0xff << 24) |
+                      (val&0xf00)<<12 | (val&0xf00)<<8 |
+                      (val&0xf0)<<8 | (val&0xf0)<<4 |
+                      (val&0xf)<<4 | (val&0xf);
+                return true;
+            }
+        }
+    }
+
+    if ( unit == CSSPrimitiveValue::CSS_IDENT ) {
+        // try a little harder
+        TQColor tc;
+        tc.setNamedColor(name.lower());
+        if ( tc.isValid() ) {
+            rgb = tc.rgb();
+            return true;
+        }
+    }
+
+    return false;
+}
+
+CSSPrimitiveValueImpl *CSSParser::parseColor()
+{
+    return parseColorFromValue(valueList->current());
+}
+
+CSSPrimitiveValueImpl *CSSParser::parseColorFromValue(Value* value)
+{
+    QRgb c = tdehtml::transparentColor;
+    if ( !strict && value->unit == CSSPrimitiveValue::CSS_NUMBER &&
+              value->fValue >= 0. && value->fValue < 1000000. ) {
+        TQString str;
+        str.sprintf( "%06d", (int)(value->fValue+.5) );
+        if ( !::parseColor( value->unit, str, c ) )
+            return 0;
+    }
+    else if (value->unit == CSSPrimitiveValue::CSS_RGBCOLOR ||
+             value->unit == CSSPrimitiveValue::CSS_IDENT ||
+             (!strict && value->unit == CSSPrimitiveValue::CSS_DIMENSION)) {
+        if ( !::parseColor( value->unit, qString( value->string ), c) )
+            return 0;
+    }
+    else if ( value->unit == Value::Function &&
+		value->function->args != 0 &&
+                value->function->args->size() == 5 /* rgb + two commas */ &&
+                qString( value->function->name ).lower() == "rgb(" ) {
+        int colorValues[3];
+        if (!parseColorParameters(value, colorValues, false))
+            return 0;
+        colorValues[0] = kMax( 0, kMin( 255, colorValues[0] ) );
+        colorValues[1] = kMax( 0, kMin( 255, colorValues[1] ) );
+        colorValues[2] = kMax( 0, kMin( 255, colorValues[2] ) );
+        c = tqRgb(colorValues[0], colorValues[1], colorValues[2]);
+    } else if (value->unit == Value::Function &&
+                value->function->args != 0 &&
+                value->function->args->size() == 7 /* rgba + three commas */ &&
+                domString(value->function->name).lower() == "rgba(") {
+        int colorValues[4];
+        if (!parseColorParameters(value, colorValues, true))
+            return 0;
+        colorValues[0] = kMax( 0, kMin( 255, colorValues[0] ) );
+        colorValues[1] = kMax( 0, kMin( 255, colorValues[1] ) );
+        colorValues[2] = kMax( 0, kMin( 255, colorValues[2] ) );
+        c = tqRgba(colorValues[0], colorValues[1], colorValues[2], colorValues[3]);
+    } else if (value->unit == Value::Function &&
+                value->function->args != 0 &&
+                value->function->args->size() == 5 /* hsl + two commas */ &&
+                domString(value->function->name).lower() == "hsl(") {
+        double colorValues[3];
+        if (!parseHSLParameters(value, colorValues, false))
+            return 0;
+        c = tdehtml::tqRgbaFromHsla(colorValues[0], colorValues[1], colorValues[2], 1.0);
+    } else if (value->unit == Value::Function &&
+                value->function->args != 0 &&
+                value->function->args->size() == 7 /* hsla + three commas */ &&
+                domString(value->function->name).lower() == "hsla(") {
+        double colorValues[4];
+        if (!parseHSLParameters(value, colorValues, true))
+            return 0;
+        c = tdehtml::tqRgbaFromHsla(colorValues[0], colorValues[1], colorValues[2], colorValues[3]);
+    }
+    else
+        return 0;
+
+    return new CSSPrimitiveValueImpl(c);
+}
+
+// This class tracks parsing state for shadow values.  If it goes out of scope (e.g., due to an early return)
+// without the allowBreak bit being set, then it will clean up all of the objects and destroy them.
+struct ShadowParseContext {
+    ShadowParseContext()
+    :values(0), x(0), y(0), blur(0), color(0),
+     allowX(true), allowY(false), allowBlur(false), allowColor(true),
+     allowBreak(true)
+    {}
+
+    ~ShadowParseContext() {
+        if (!allowBreak) {
+            delete values;
+            delete x;
+            delete y;
+            delete blur;
+            delete color;
+        }
+    }
+
+    bool allowLength() { return allowX || allowY || allowBlur; }
+
+    bool failed() { return allowBreak = false; }
+
+    void commitValue() {
+        // Handle the ,, case gracefully by doing nothing.
+        if (x || y || blur || color) {
+            if (!values)
+                values = new CSSValueListImpl();
+
+            // Construct the current shadow value and add it to the list.
+            values->append(new ShadowValueImpl(x, y, blur, color));
+        }
+
+        // Now reset for the next shadow value.
+        x = y = blur = color = 0;
+        allowX = allowColor = allowBreak = true;
+        allowY = allowBlur = false;
+    }
+
+    void commitLength(Value* v) {
+        CSSPrimitiveValueImpl* val = new CSSPrimitiveValueImpl(v->fValue,
+                                                               (CSSPrimitiveValue::UnitTypes)v->unit);
+        if (allowX) {
+            x = val;
+            allowX = false; allowY = true; allowColor = false; allowBreak = false;
+        }
+        else if (allowY) {
+            y = val;
+            allowY = false; allowBlur = true; allowColor = true; allowBreak = true;
+        }
+        else if (allowBlur) {
+            blur = val;
+            allowBlur = false;
+        }
+	else
+	    delete val;
+    }
+
+    void commitColor(CSSPrimitiveValueImpl* val) {
+        color = val;
+        allowColor = false;
+        if (allowX)
+            allowBreak = false;
+        else
+            allowBlur = false;
+    }
+
+    CSSValueListImpl* values;
+    CSSPrimitiveValueImpl* x;
+    CSSPrimitiveValueImpl* y;
+    CSSPrimitiveValueImpl* blur;
+    CSSPrimitiveValueImpl* color;
+
+    bool allowX;
+    bool allowY;
+    bool allowBlur;
+    bool allowColor;
+    bool allowBreak;
+};
+
+bool CSSParser::parseShadow(int propId, bool important)
+{
+    ShadowParseContext context;
+    Value* val;
+    while ((val = valueList->current())) {
+        // Check for a comma break first.
+        if (val->unit == Value::Operator) {
+            if (val->iValue != ',' || !context.allowBreak)
+                // Other operators aren't legal or we aren't done with the current shadow
+                // value.  Treat as invalid.
+                return context.failed();
+
+            // The value is good.  Commit it.
+            context.commitValue();
+        }
+        // Check to see if we're a length.
+        else if (validUnit(val, FLength, true)) {
+            // We required a length and didn't get one. Invalid.
+            if (!context.allowLength())
+                return context.failed();
+
+            // A length is allowed here.  Construct the value and add it.
+            context.commitLength(val);
+        }
+        else {
+            // The only other type of value that's ok is a color value.
+            CSSPrimitiveValueImpl* parsedColor = 0;
+            bool isColor = (val->id >= CSS_VAL_AQUA && val->id <= CSS_VAL_WINDOWTEXT || val->id == CSS_VAL_MENU ||
+                           (val->id >= CSS_VAL_GREY && val->id <= CSS_VAL__KHTML_TEXT && !strict));
+	    if (!context.allowColor)
+                return context.failed();
+
+            if (isColor)
+               parsedColor = new CSSPrimitiveValueImpl(val->id);
+
+            if (!parsedColor)
+                // It's not built-in. Try to parse it as a color.
+                parsedColor = parseColorFromValue(val);
+
+            if (!parsedColor)
+                return context.failed();
+
+            context.commitColor(parsedColor);
+        }
+
+        valueList->next();
+    }
+
+    if (context.allowBreak) {
+        context.commitValue();
+        if (context.values->length()) {
+            addProperty(propId, context.values, important);
+            valueList->next();
+            return true;
+        }
+    }
+
+    return context.failed();
+}
+
+bool CSSParser::parseCounter(int propId, bool increment, bool important)
+{
+    enum { ID, VAL, COMMA } state = ID;
+
+    CSSValueListImpl *list = new CSSValueListImpl;
+    DOMString c;
+    Value* val;
+    while (true) {
+        val = valueList->current();
+        switch (state) {
+            // Commas are not allowed according to the standard, but Opera allows them and being the only
+            // other browser with counter support we need to match their behavior to work with current use
+            case COMMA:
+                state = ID;
+                if (val && val->unit == Value::Operator && val->iValue == ',') {
+                    valueList->next();
+                    continue;
+                }
+                // no break
+            case ID:
+                if (val && val->unit == CSSPrimitiveValue::CSS_IDENT) {
+                    c = qString(val->string);
+                    state = VAL;
+                    valueList->next();
+                    continue;
+                }
+                break;
+            case VAL: {
+                short i = 0;
+                if (val && val->unit == CSSPrimitiveValue::CSS_NUMBER) {
+                    i = (short)val->fValue;
+                    valueList->next();
+                } else
+                    i = (increment) ? 1 : 0;
+
+                CounterActImpl *cv = new CounterActImpl(c,i);
+                list->append(cv);
+                state = COMMA;
+                continue;
+            }
+        }
+        break;
+    }
+    if(list->length() > 0) {
+        addProperty( propId, list, important );
+        return true;
+    }
+    delete list;
+    return false;
+}
+
+static inline int yyerror( const char *str ) {
+//    assert( 0 );
+#ifdef CSS_DEBUG
+    kdDebug( 6080 ) << "CSS parse error " << str << endl;
+#else
+    Q_UNUSED( str );
+#endif
+    return 1;
+}
+
+#define END 0
+
+#include "parser.h"
+
+int DOM::CSSParser::lex( void *_yylval )
+{
+    YYSTYPE *yylval = (YYSTYPE *)_yylval;
+    int token = lex();
+    int length;
+    unsigned short *t = text( &length );
+
+#ifdef TOKEN_DEBUG
+    tqDebug("CSSTokenizer: got token %d: '%s'", token, token == END ? "" : TQString( (TQChar *)t, length ).latin1() );
+#endif
+    switch( token ) {
+    case '{':
+        block_nesting++;
+        break;
+    case '}':
+        if ( block_nesting )
+            block_nesting--;
+        break;
+    case END:
+        if ( block_nesting ) {
+            block_nesting--;
+            return '}';
+        }
+        break;
+    case S:
+    case SGML_CD:
+    case INCLUDES:
+    case DASHMATCH:
+        break;
+
+    case URI:
+    case STRING:
+    case IDENT:
+    case NTH:
+    case HASH:
+    case DIMEN:
+    case UNICODERANGE:
+    case NOTFUNCTION:
+    case FUNCTION:
+        yylval->string.string = t;
+        yylval->string.length = length;
+        break;
+
+    case IMPORT_SYM:
+    case PAGE_SYM:
+    case MEDIA_SYM:
+    case FONT_FACE_SYM:
+    case CHARSET_SYM:
+    case NAMESPACE_SYM:
+
+    case IMPORTANT_SYM:
+        break;
+
+    case QEMS:
+        length--;
+    case GRADS:
+        length--;
+    case DEGS:
+    case RADS:
+    case KHERZ:
+        length--;
+    case MSECS:
+    case HERZ:
+    case EMS:
+    case EXS:
+    case PXS:
+    case CMS:
+    case MMS:
+    case INS:
+    case PTS:
+    case PCS:
+        length--;
+    case SECS:
+    case PERCENTAGE:
+        length--;
+    case FLOAT:
+    case INTEGER:
+        yylval->val = TQString( (TQChar *)t, length ).toDouble();
+        //tqDebug("value = %s, converted=%.2f", TQString( (TQChar *)t, length ).latin1(), yylval->val );
+        break;
+
+    default:
+        break;
+    }
+
+    return token;
+}
+
+static inline int toHex( char c ) {
+    if ( '0' <= c && c <= '9' )
+        return c - '0';
+    if ( 'a' <= c && c <= 'f' )
+        return c - 'a' + 10;
+    if ( 'A' <= c && c<= 'F' )
+        return c - 'A' + 10;
+    return 0;
+}
+
+unsigned short *DOM::CSSParser::text(int *length)
+{
+    unsigned short *start = yytext;
+    int l = yyleng;
+    switch( yyTok ) {
+    case STRING:
+        l--;
+        /* nobreak */
+    case HASH:
+        start++;
+        l--;
+        break;
+    case URI:
+        // "url("{w}{string}{w}")"
+        // "url("{w}{url}{w}")"
+
+        // strip "url(" and ")"
+        start += 4;
+        l -= 5;
+        // strip {w}
+        while ( l &&
+                (*start == ' ' || *start == '\t' || *start == '\r' ||
+                 *start == '\n' || *start == '\f' ) ) {
+            start++; l--;
+        }
+        if ( *start == '"' || *start == '\'' ) {
+            start++; l--;
+        }
+        while ( l &&
+                (start[l-1] == ' ' || start[l-1] == '\t' || start[l-1] == '\r' ||
+                 start[l-1] == '\n' || start[l-1] == '\f' ) ) {
+            l--;
+        }
+        if ( l && (start[l-1] == '\"' || start[l-1] == '\'' ) )
+             l--;
+
+    default:
+        break;
+    }
+
+    // process escapes
+    unsigned short *out = start;
+    unsigned short *escape = 0;
+
+    for ( int i = 0; i < l; i++ ) {
+        unsigned short *current = start+i;
+        if ( escape == current - 1 ) {
+            if ( ( *current >= '0' && *current <= '9' ) ||
+                 ( *current >= 'a' && *current <= 'f' ) ||
+                 ( *current >= 'A' && *current <= 'F' ) )
+                continue;
+            if ( yyTok == STRING &&
+                 ( *current == '\n' || *current == '\r' || *current == '\f' ) ) {
+                // ### handle \r\n case
+                if ( *current != '\r' )
+                    escape = 0;
+                continue;
+            }
+            // in all other cases copy the char to output
+            // ###
+            *out++ = *current;
+            escape = 0;
+            continue;
+        }
+        if ( escape == current - 2 && yyTok == STRING &&
+             *(current-1) == '\r' && *current == '\n' ) {
+            escape = 0;
+            continue;
+        }
+        if ( escape > current - 7 &&
+             ( ( *current >= '0' && *current <= '9' ) ||
+               ( *current >= 'a' && *current <= 'f' ) ||
+               ( *current >= 'A' && *current <= 'F' ) ) )
+                continue;
+        if ( escape ) {
+            // add escaped char
+            int uc = 0;
+            escape++;
+            while ( escape < current ) {
+//                 tqDebug("toHex( %c = %x", (char)*escape, toHex( *escape ) );
+                uc *= 16;
+                uc += toHex( *escape );
+                escape++;
+            }
+//             tqDebug(" converting escape: string='%s', value=0x%x", TQString( (TQChar *)e, current-e ).latin1(), uc );
+            // can't handle chars outside ucs2
+            if ( uc > 0xffff )
+                uc = 0xfffd;
+            *(out++) = (unsigned short)uc;
+            escape = 0;
+            if ( *current == ' ' ||
+                 *current == '\t' ||
+                 *current == '\r' ||
+                 *current == '\n' ||
+                 *current == '\f' )
+                continue;
+        }
+        if ( !escape && *current == '\\' ) {
+            escape = current;
+            continue;
+        }
+        *(out++) = *current;
+    }
+    if ( escape ) {
+        // add escaped char
+        int uc = 0;
+        escape++;
+        while ( escape < start+l ) {
+            //                 tqDebug("toHex( %c = %x", (char)*escape, toHex( *escape ) );
+            uc *= 16;
+            uc += toHex( *escape );
+            escape++;
+        }
+        //             tqDebug(" converting escape: string='%s', value=0x%x", TQString( (TQChar *)e, current-e ).latin1(), uc );
+        // can't handle chars outside ucs2
+        if ( uc > 0xffff )
+            uc = 0xfffd;
+        *(out++) = (unsigned short)uc;
+    }
+
+    *length = out - start;
+    return start;
+}
+
+
+#define YY_DECL int DOM::CSSParser::lex()
+#define yyconst const
+typedef int yy_state_type;
+typedef unsigned int YY_CHAR;
+// this line makes sure we treat all Unicode chars correctly.
+#define YY_SC_TO_UI(c) (c > 0xff ? 0xff : c)
+#define YY_DO_BEFORE_ACTION \
+        yytext = yy_bp; \
+        yyleng = (int) (yy_cp - yy_bp); \
+        yy_hold_char = *yy_cp; \
+        *yy_cp = 0; \
+        yy_c_buf_p = yy_cp;
+#define YY_BREAK break;
+#define ECHO tqDebug( "%s", TQString( (TQChar *)yytext, yyleng ).latin1() )
+#define YY_RULE_SETUP
+#define INITIAL 0
+#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
+#define YY_START ((yy_start - 1) / 2)
+#define yyterminate() yyTok = END; return yyTok
+#define YY_FATAL_ERROR(a) tqFatal(a)
+#define BEGIN yy_start = 1 + 2 *
+#define COMMENT 1
+
+#include "tokenizer.cpp"
diff --git a/tdehtml/css/cssparser.h b/tdehtml/css/cssparser.h
new file mode 100644
index 000000000..0e00ebc16
--- /dev/null
+++ b/tdehtml/css/cssparser.h
@@ -0,0 +1,201 @@
+/*
+ * This file is part of the DOM implementation for KDE.
+ *
+ * Copyright (C) 2003 Lars Knoll (knoll@kde.org)
+ * Copyright (C) 2004, 2005, 2006 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 _CSS_cssparser_h_
+#define _CSS_cssparser_h_
+
+#include <tqstring.h>
+#include <tqcolor.h>
+#include <tqvaluevector.h>
+#include <dom/dom_string.h>
+
+namespace DOM {
+    class StyleListImpl;
+    class CSSStyleSheetImpl;
+    class CSSRuleImpl;
+    class CSSStyleRuleImpl;
+    class DocumentImpl;
+    class CSSValueImpl;
+    class CSSValueListImpl;
+    class CSSPrimitiveValueImpl;
+    class CSSStyleDeclarationImpl;
+    class CSSProperty;
+    class CSSRuleListImpl;
+
+
+    struct ParseString {
+	unsigned short *string;
+	int length;
+    };
+
+    struct Value;
+    class ValueList;
+
+    struct Function {
+	ParseString name;
+	ValueList *args;
+    };
+
+    struct Value {
+	int id;
+        bool isInt;
+	union {
+	    double fValue;
+	    int iValue;
+	    ParseString string;
+	    struct Function *function;
+	};
+	enum {
+	    Operator = 0x100000,
+	    Function = 0x100001,
+	    Q_EMS     = 0x100002
+	};
+
+	int unit;
+    };
+
+    static inline TQString qString( const ParseString &ps ) {
+	return TQString( (TQChar *)ps.string, ps.length );
+    }
+    static inline DOMString domString( const ParseString &ps ) {
+	return DOMString( (TQChar *)ps.string, ps.length );
+    }
+
+    class ValueList {
+    public:
+        ValueList() : m_current(0) { }
+	~ValueList();
+        void addValue(const Value& v) { m_values.append(v); }
+        unsigned int size() const { return m_values.size(); }
+        Value* current() { return m_current < m_values.size() ? &m_values[m_current] : 0; }
+        Value* next() { ++m_current; return current(); }
+    private:
+        TQValueVector<Value> m_values;
+	unsigned int m_current;
+    };
+
+    class CSSParser
+    {
+    public:
+	CSSParser( bool strictParsing = true );
+	~CSSParser();
+
+	void parseSheet( DOM::CSSStyleSheetImpl *sheet, const DOM::DOMString &string );
+	DOM::CSSRuleImpl *parseRule( DOM::CSSStyleSheetImpl *sheet, const DOM::DOMString &string );
+	bool parseValue( DOM::CSSStyleDeclarationImpl *decls, int id, const DOM::DOMString &string,
+			 bool _important, bool _nonCSSHint );
+	bool parseDeclaration( DOM::CSSStyleDeclarationImpl *decls, const DOM::DOMString &string,
+			       bool _nonCSSHint );
+
+	static CSSParser *current() { return currentParser; }
+
+
+	DOM::DocumentImpl *document() const;
+
+	unsigned int defaultNamespace();
+
+	void addProperty( int propId, CSSValueImpl *value, bool important );
+	bool hasProperties() const { return numParsedProperties > 0; }
+	CSSStyleDeclarationImpl *createStyleDeclaration( CSSStyleRuleImpl *rule );
+	void clearProperties();
+
+	bool parseValue( int propId, bool important );
+	bool parseShortHand( int propId, const int *properties, int numProperties, bool important );
+	bool parse4Values( int propId, const int *properties, bool important );
+	bool parseContent( int propId, bool important );
+
+        CSSValueImpl* parseBackgroundColor();
+        CSSValueImpl* parseBackgroundImage();
+        CSSValueImpl* parseBackgroundPositionXY(bool& xFound, bool& yFound);
+        void parseBackgroundPosition(CSSValueImpl*& value1, CSSValueImpl*& value2);
+        CSSValueImpl* parseBackgroundSize();
+
+        bool parseBackgroundProperty(int propId, int& propId1, int& propId2, CSSValueImpl*& retValue1, CSSValueImpl*& retValue2);
+        bool parseBackgroundShorthand(bool important);
+
+        void addBackgroundValue(CSSValueImpl*& lval, CSSValueImpl* rval);
+
+	bool parseShape( int propId, bool important );
+	bool parseFont(bool important);
+        bool parseCounter(int propId, bool increment, bool important);
+
+        bool parseColorParameters(Value*, int* colorValues, bool parseAlpha);
+        bool parseHSLParameters(Value*, double* colorValues, bool parseAlpha);
+
+        // returns the found property
+        // 0 if nothing found (or ok == false)
+        // @param forward if true, it parses the next in the list
+	CSSValueListImpl *parseFontFamily();
+        CSSPrimitiveValueImpl *parseColor();
+        CSSPrimitiveValueImpl *parseColorFromValue(Value* val);
+        CSSValueImpl* parseCounterContent(ValueList *args, bool counters);
+
+        static bool parseColor(const TQString &name, QRgb& rgb);
+
+        // CSS3 Parsing Routines (for properties specific to CSS3)
+        bool parseShadow(int propId, bool important);
+
+        bool parseBorderImage(int propId, bool important);
+
+    public:
+	bool strict;
+	bool important;
+	bool nonCSSHint;
+	unsigned int id;
+	DOM::StyleListImpl* styleElement;
+	DOM::CSSRuleImpl *rule;
+	ValueList *valueList;
+	CSSProperty **parsedProperties;
+	int numParsedProperties;
+	int maxParsedProperties;
+
+        int m_inParseShorthand;
+        int m_currentShorthand;
+        bool m_implicitShorthand;
+
+	static CSSParser *currentParser;
+
+	// tokenizer methods and data
+    public:
+	int lex( void *yylval );
+	int token() { return yyTok; }
+	unsigned short *text( int *length);
+	int lex();
+    private:
+	int yyparse();
+        void runParser(int length);
+
+        bool inShorthand() const { return m_inParseShorthand; }
+
+	unsigned short *data;
+	unsigned short *yytext;
+	unsigned short *yy_c_buf_p;
+	unsigned short yy_hold_char;
+	int yy_last_accepting_state;
+	unsigned short *yy_last_accepting_cpos;
+        int block_nesting;
+	int yyleng;
+	int yyTok;
+	int yy_start;
+    };
+
+} // namespace
+#endif
diff --git a/tdehtml/css/cssproperties.c b/tdehtml/css/cssproperties.c
new file mode 100644
index 000000000..da5208412
--- /dev/null
+++ b/tdehtml/css/cssproperties.c
@@ -0,0 +1,678 @@
+/* ANSI-C code produced by gperf version 3.0.2 */
+/* Command-line: gperf -a -L ANSI-C -E -C -c -o -t -k '*' -NfindProp -Hhash_prop -Wwordlist_prop -D -s 2 cssproperties.gperf  */
+
+#if !((' ' == 32) && ('!' == 33) && ('"' == 34) && ('#' == 35) \
+      && ('%' == 37) && ('&' == 38) && ('\'' == 39) && ('(' == 40) \
+      && (')' == 41) && ('*' == 42) && ('+' == 43) && (',' == 44) \
+      && ('-' == 45) && ('.' == 46) && ('/' == 47) && ('0' == 48) \
+      && ('1' == 49) && ('2' == 50) && ('3' == 51) && ('4' == 52) \
+      && ('5' == 53) && ('6' == 54) && ('7' == 55) && ('8' == 56) \
+      && ('9' == 57) && (':' == 58) && (';' == 59) && ('<' == 60) \
+      && ('=' == 61) && ('>' == 62) && ('?' == 63) && ('A' == 65) \
+      && ('B' == 66) && ('C' == 67) && ('D' == 68) && ('E' == 69) \
+      && ('F' == 70) && ('G' == 71) && ('H' == 72) && ('I' == 73) \
+      && ('J' == 74) && ('K' == 75) && ('L' == 76) && ('M' == 77) \
+      && ('N' == 78) && ('O' == 79) && ('P' == 80) && ('Q' == 81) \
+      && ('R' == 82) && ('S' == 83) && ('T' == 84) && ('U' == 85) \
+      && ('V' == 86) && ('W' == 87) && ('X' == 88) && ('Y' == 89) \
+      && ('Z' == 90) && ('[' == 91) && ('\\' == 92) && (']' == 93) \
+      && ('^' == 94) && ('_' == 95) && ('a' == 97) && ('b' == 98) \
+      && ('c' == 99) && ('d' == 100) && ('e' == 101) && ('f' == 102) \
+      && ('g' == 103) && ('h' == 104) && ('i' == 105) && ('j' == 106) \
+      && ('k' == 107) && ('l' == 108) && ('m' == 109) && ('n' == 110) \
+      && ('o' == 111) && ('p' == 112) && ('q' == 113) && ('r' == 114) \
+      && ('s' == 115) && ('t' == 116) && ('u' == 117) && ('v' == 118) \
+      && ('w' == 119) && ('x' == 120) && ('y' == 121) && ('z' == 122) \
+      && ('{' == 123) && ('|' == 124) && ('}' == 125) && ('~' == 126))
+/* The character set is not based on ISO-646.  */
+#error "gperf generated tables don't work with this execution character set. Please report a bug to <bug-gnu-gperf@gnu.org>."
+#endif
+
+#line 1 "cssproperties.gperf"
+
+/* This file is automatically generated from cssproperties.in by makeprop, do not edit */
+/* Copyright 1999 W. Bastian */
+#include "cssproperties.h"
+#line 6 "cssproperties.gperf"
+struct props {
+    const char *name;
+    int id;
+};
+
+static const struct props * findProp (register const char *str, register unsigned int len);
+/* maximum key range = 469, duplicates = 0 */
+
+#ifdef __GNUC__
+__inline
+#else
+#ifdef __cplusplus
+inline
+#endif
+#endif
+static unsigned int
+hash_prop (register const char *str, register unsigned int len)
+{
+  static const unsigned short asso_values[] =
+    {
+      472, 472, 472, 472, 472, 472, 472, 472, 472, 472,
+      472, 472, 472, 472, 472, 472, 472, 472, 472, 472,
+      472, 472, 472, 472, 472, 472, 472, 472, 472, 472,
+      472, 472, 472, 472, 472, 472, 472, 472, 472, 472,
+      472, 472, 472, 472, 472,   0, 472, 472, 472, 472,
+      472,   0, 472, 472, 472, 472, 472, 472, 472, 472,
+      472, 472, 472, 472, 472, 472, 472, 472, 472, 472,
+      472, 472, 472, 472, 472, 472, 472, 472, 472, 472,
+      472, 472, 472, 472, 472, 472, 472, 472, 472, 472,
+      472, 472, 472, 472, 472, 472, 472,  10,   0,   0,
+        5,   5, 120,   0,   0,   0, 472,  15,   5,   0,
+       25,   0,   0,  50,   0,  30,   0,  40,   0, 140,
+       35, 180,  80, 472, 472, 472, 472, 472, 472, 472,
+      472, 472, 472, 472, 472, 472, 472, 472, 472, 472,
+      472, 472, 472, 472, 472, 472, 472, 472, 472, 472,
+      472, 472, 472, 472, 472, 472, 472, 472, 472, 472,
+      472, 472, 472, 472, 472, 472, 472, 472, 472, 472,
+      472, 472, 472, 472, 472, 472, 472, 472, 472, 472,
+      472, 472, 472, 472, 472, 472, 472, 472, 472, 472,
+      472, 472, 472, 472, 472, 472, 472, 472, 472, 472,
+      472, 472, 472, 472, 472, 472, 472, 472, 472, 472,
+      472, 472, 472, 472, 472, 472, 472, 472, 472, 472,
+      472, 472, 472, 472, 472, 472, 472, 472, 472, 472,
+      472, 472, 472, 472, 472, 472, 472, 472, 472, 472,
+      472, 472, 472, 472, 472, 472, 472, 472, 472, 472,
+      472, 472, 472, 472, 472, 472
+    };
+  register int hval = len;
+
+  switch (hval)
+    {
+      default:
+        hval += asso_values[(unsigned char)str[31]];
+      /*FALLTHROUGH*/
+      case 31:
+        hval += asso_values[(unsigned char)str[30]];
+      /*FALLTHROUGH*/
+      case 30:
+        hval += asso_values[(unsigned char)str[29]];
+      /*FALLTHROUGH*/
+      case 29:
+        hval += asso_values[(unsigned char)str[28]];
+      /*FALLTHROUGH*/
+      case 28:
+        hval += asso_values[(unsigned char)str[27]];
+      /*FALLTHROUGH*/
+      case 27:
+        hval += asso_values[(unsigned char)str[26]];
+      /*FALLTHROUGH*/
+      case 26:
+        hval += asso_values[(unsigned char)str[25]];
+      /*FALLTHROUGH*/
+      case 25:
+        hval += asso_values[(unsigned char)str[24]];
+      /*FALLTHROUGH*/
+      case 24:
+        hval += asso_values[(unsigned char)str[23]];
+      /*FALLTHROUGH*/
+      case 23:
+        hval += asso_values[(unsigned char)str[22]];
+      /*FALLTHROUGH*/
+      case 22:
+        hval += asso_values[(unsigned char)str[21]];
+      /*FALLTHROUGH*/
+      case 21:
+        hval += asso_values[(unsigned char)str[20]];
+      /*FALLTHROUGH*/
+      case 20:
+        hval += asso_values[(unsigned char)str[19]];
+      /*FALLTHROUGH*/
+      case 19:
+        hval += asso_values[(unsigned char)str[18]];
+      /*FALLTHROUGH*/
+      case 18:
+        hval += asso_values[(unsigned char)str[17]];
+      /*FALLTHROUGH*/
+      case 17:
+        hval += asso_values[(unsigned char)str[16]];
+      /*FALLTHROUGH*/
+      case 16:
+        hval += asso_values[(unsigned char)str[15]];
+      /*FALLTHROUGH*/
+      case 15:
+        hval += asso_values[(unsigned char)str[14]];
+      /*FALLTHROUGH*/
+      case 14:
+        hval += asso_values[(unsigned char)str[13]];
+      /*FALLTHROUGH*/
+      case 13:
+        hval += asso_values[(unsigned char)str[12]];
+      /*FALLTHROUGH*/
+      case 12:
+        hval += asso_values[(unsigned char)str[11]];
+      /*FALLTHROUGH*/
+      case 11:
+        hval += asso_values[(unsigned char)str[10]];
+      /*FALLTHROUGH*/
+      case 10:
+        hval += asso_values[(unsigned char)str[9]];
+      /*FALLTHROUGH*/
+      case 9:
+        hval += asso_values[(unsigned char)str[8]];
+      /*FALLTHROUGH*/
+      case 8:
+        hval += asso_values[(unsigned char)str[7]];
+      /*FALLTHROUGH*/
+      case 7:
+        hval += asso_values[(unsigned char)str[6]];
+      /*FALLTHROUGH*/
+      case 6:
+        hval += asso_values[(unsigned char)str[5]];
+      /*FALLTHROUGH*/
+      case 5:
+        hval += asso_values[(unsigned char)str[4]];
+      /*FALLTHROUGH*/
+      case 4:
+        hval += asso_values[(unsigned char)str[3]];
+      /*FALLTHROUGH*/
+      case 3:
+        hval += asso_values[(unsigned char)str[2]];
+      /*FALLTHROUGH*/
+      case 2:
+        hval += asso_values[(unsigned char)str[1]];
+      /*FALLTHROUGH*/
+      case 1:
+        hval += asso_values[(unsigned char)str[0]];
+        break;
+    }
+  return hval;
+}
+
+#ifdef __GNUC__
+__inline
+#endif
+const struct props *
+findProp (register const char *str, register unsigned int len)
+{
+  enum
+    {
+      TOTAL_KEYWORDS = 129,
+      MIN_WORD_LENGTH = 3,
+      MAX_WORD_LENGTH = 32,
+      MIN_HASH_VALUE = 3,
+      MAX_HASH_VALUE = 471
+    };
+
+  static const struct props wordlist_prop[] =
+    {
+#line 108 "cssproperties.gperf"
+      {"top", CSS_PROP_TOP},
+#line 99 "cssproperties.gperf"
+      {"right", CSS_PROP_RIGHT},
+#line 40 "cssproperties.gperf"
+      {"bottom", CSS_PROP_BOTTOM},
+#line 43 "cssproperties.gperf"
+      {"clip", CSS_PROP_CLIP},
+#line 44 "cssproperties.gperf"
+      {"color", CSS_PROP_COLOR},
+#line 58 "cssproperties.gperf"
+      {"height", CSS_PROP_HEIGHT},
+#line 119 "cssproperties.gperf"
+      {"border", CSS_PROP_BORDER},
+#line 122 "cssproperties.gperf"
+      {"border-top", CSS_PROP_BORDER_TOP},
+#line 123 "cssproperties.gperf"
+      {"border-right", CSS_PROP_BORDER_RIGHT},
+#line 124 "cssproperties.gperf"
+      {"border-bottom", CSS_PROP_BORDER_BOTTOM},
+#line 42 "cssproperties.gperf"
+      {"clear", CSS_PROP_CLEAR},
+#line 120 "cssproperties.gperf"
+      {"border-color", CSS_PROP_BORDER_COLOR},
+#line 28 "cssproperties.gperf"
+      {"border-top-color", CSS_PROP_BORDER_TOP_COLOR},
+#line 29 "cssproperties.gperf"
+      {"border-right-color", CSS_PROP_BORDER_RIGHT_COLOR},
+#line 30 "cssproperties.gperf"
+      {"border-bottom-color", CSS_PROP_BORDER_BOTTOM_COLOR},
+#line 78 "cssproperties.gperf"
+      {"min-height", CSS_PROP_MIN_HEIGHT},
+#line 130 "cssproperties.gperf"
+      {"margin", CSS_PROP_MARGIN},
+#line 49 "cssproperties.gperf"
+      {"direction", CSS_PROP_DIRECTION},
+#line 65 "cssproperties.gperf"
+      {"margin-top", CSS_PROP_MARGIN_TOP},
+#line 66 "cssproperties.gperf"
+      {"margin-right", CSS_PROP_MARGIN_RIGHT},
+#line 67 "cssproperties.gperf"
+      {"margin-bottom", CSS_PROP_MARGIN_BOTTOM},
+#line 61 "cssproperties.gperf"
+      {"line-height", CSS_PROP_LINE_HEIGHT},
+#line 132 "cssproperties.gperf"
+      {"padding", CSS_PROP_PADDING},
+#line 89 "cssproperties.gperf"
+      {"padding-top", CSS_PROP_PADDING_TOP},
+#line 90 "cssproperties.gperf"
+      {"padding-right", CSS_PROP_PADDING_RIGHT},
+#line 91 "cssproperties.gperf"
+      {"padding-bottom", CSS_PROP_PADDING_BOTTOM},
+#line 76 "cssproperties.gperf"
+      {"max-height", CSS_PROP_MAX_HEIGHT},
+#line 45 "cssproperties.gperf"
+      {"content", CSS_PROP_CONTENT},
+#line 97 "cssproperties.gperf"
+      {"position", CSS_PROP_POSITION},
+#line 80 "cssproperties.gperf"
+      {"orphans", CSS_PROP_ORPHANS},
+#line 110 "cssproperties.gperf"
+      {"vertical-align", CSS_PROP_VERTICAL_ALIGN},
+#line 48 "cssproperties.gperf"
+      {"cursor", CSS_PROP_CURSOR},
+#line 24 "cssproperties.gperf"
+      {"border-collapse", CSS_PROP_BORDER_COLLAPSE},
+#line 131 "cssproperties.gperf"
+      {"outline", CSS_PROP_OUTLINE},
+#line 136 "cssproperties.gperf"
+      {"scrollbar-highlight-color", CSS_PROP_SCROLLBAR_HIGHLIGHT_COLOR},
+#line 41 "cssproperties.gperf"
+      {"caption-side", CSS_PROP_CAPTION_SIDE},
+#line 137 "cssproperties.gperf"
+      {"scrollbar-3dlight-color", CSS_PROP_SCROLLBAR_3DLIGHT_COLOR},
+#line 25 "cssproperties.gperf"
+      {"border-spacing", CSS_PROP_BORDER_SPACING},
+#line 102 "cssproperties.gperf"
+      {"text-align", CSS_PROP_TEXT_ALIGN},
+#line 109 "cssproperties.gperf"
+      {"unicode-bidi", CSS_PROP_UNICODE_BIDI},
+#line 82 "cssproperties.gperf"
+      {"outline-color", CSS_PROP_OUTLINE_COLOR},
+#line 60 "cssproperties.gperf"
+      {"letter-spacing", CSS_PROP_LETTER_SPACING},
+#line 103 "cssproperties.gperf"
+      {"text-decoration", CSS_PROP_TEXT_DECORATION},
+#line 139 "cssproperties.gperf"
+      {"scrollbar-track-color", CSS_PROP_SCROLLBAR_TRACK_COLOR},
+#line 118 "cssproperties.gperf"
+      {"background", CSS_PROP_BACKGROUND},
+#line 104 "cssproperties.gperf"
+      {"text-indent", CSS_PROP_TEXT_INDENT},
+#line 69 "cssproperties.gperf"
+      {"-tdehtml-margin-start", CSS_PROP__KHTML_MARGIN_START},
+#line 14 "cssproperties.gperf"
+      {"background-color", CSS_PROP_BACKGROUND_COLOR},
+#line 100 "cssproperties.gperf"
+      {"size", CSS_PROP_SIZE},
+#line 133 "cssproperties.gperf"
+      {"scrollbar-base-color", CSS_PROP_SCROLLBAR_BASE_COLOR},
+#line 47 "cssproperties.gperf"
+      {"counter-reset", CSS_PROP_COUNTER_RESET},
+#line 93 "cssproperties.gperf"
+      {"-tdehtml-padding-start", CSS_PROP__KHTML_PADDING_START},
+#line 15 "cssproperties.gperf"
+      {"background-image", CSS_PROP_BACKGROUND_IMAGE},
+#line 96 "cssproperties.gperf"
+      {"page-break-inside", CSS_PROP_PAGE_BREAK_INSIDE},
+#line 98 "cssproperties.gperf"
+      {"quotes", CSS_PROP_QUOTES},
+#line 16 "cssproperties.gperf"
+      {"background-repeat", CSS_PROP_BACKGROUND_REPEAT},
+#line 59 "cssproperties.gperf"
+      {"left", CSS_PROP_LEFT},
+#line 52 "cssproperties.gperf"
+      {"float", CSS_PROP_FLOAT},
+#line 21 "cssproperties.gperf"
+      {"-tdehtml-background-clip", CSS_PROP__KHTML_BACKGROUND_CLIP},
+#line 70 "cssproperties.gperf"
+      {"-tdehtml-marquee", CSS_PROP__KHTML_MARQUEE},
+#line 27 "cssproperties.gperf"
+      {"-tdehtml-border-vertical-spacing", CSS_PROP__KHTML_BORDER_VERTICAL_SPACING},
+#line 46 "cssproperties.gperf"
+      {"counter-increment", CSS_PROP_COUNTER_INCREMENT},
+#line 128 "cssproperties.gperf"
+      {"font", CSS_PROP_FONT},
+#line 114 "cssproperties.gperf"
+      {"width", CSS_PROP_WIDTH},
+#line 125 "cssproperties.gperf"
+      {"border-left", CSS_PROP_BORDER_LEFT},
+#line 117 "cssproperties.gperf"
+      {"z-index", CSS_PROP_Z_INDEX},
+#line 31 "cssproperties.gperf"
+      {"border-left-color", CSS_PROP_BORDER_LEFT_COLOR},
+#line 22 "cssproperties.gperf"
+      {"-tdehtml-background-origin", CSS_PROP__KHTML_BACKGROUND_ORIGIN},
+#line 17 "cssproperties.gperf"
+      {"background-attachment", CSS_PROP_BACKGROUND_ATTACHMENT},
+#line 126 "cssproperties.gperf"
+      {"border-width", CSS_PROP_BORDER_WIDTH},
+#line 18 "cssproperties.gperf"
+      {"background-position", CSS_PROP_BACKGROUND_POSITION},
+#line 36 "cssproperties.gperf"
+      {"border-top-width", CSS_PROP_BORDER_TOP_WIDTH},
+#line 37 "cssproperties.gperf"
+      {"border-right-width", CSS_PROP_BORDER_RIGHT_WIDTH},
+#line 38 "cssproperties.gperf"
+      {"border-bottom-width", CSS_PROP_BORDER_BOTTOM_WIDTH},
+#line 68 "cssproperties.gperf"
+      {"margin-left", CSS_PROP_MARGIN_LEFT},
+#line 142 "cssproperties.gperf"
+      {"-tdehtml-user-input", CSS_PROP__KHTML_USER_INPUT},
+#line 79 "cssproperties.gperf"
+      {"min-width", CSS_PROP_MIN_WIDTH},
+#line 127 "cssproperties.gperf"
+      {"box-sizing", CSS_PROP_BOX_SIZING},
+#line 92 "cssproperties.gperf"
+      {"padding-left", CSS_PROP_PADDING_LEFT},
+#line 71 "cssproperties.gperf"
+      {"-tdehtml-marquee-direction", CSS_PROP__KHTML_MARQUEE_DIRECTION},
+#line 73 "cssproperties.gperf"
+      {"-tdehtml-marquee-repetition", CSS_PROP__KHTML_MARQUEE_REPETITION},
+#line 95 "cssproperties.gperf"
+      {"page-break-before", CSS_PROP_PAGE_BREAK_BEFORE},
+#line 74 "cssproperties.gperf"
+      {"-tdehtml-marquee-speed", CSS_PROP__KHTML_MARQUEE_SPEED},
+#line 94 "cssproperties.gperf"
+      {"page-break-after", CSS_PROP_PAGE_BREAK_AFTER},
+#line 81 "cssproperties.gperf"
+      {"opacity", CSS_PROP_OPACITY},
+#line 77 "cssproperties.gperf"
+      {"max-width", CSS_PROP_MAX_WIDTH},
+#line 112 "cssproperties.gperf"
+      {"white-space", CSS_PROP_WHITE_SPACE},
+#line 56 "cssproperties.gperf"
+      {"font-variant", CSS_PROP_FONT_VARIANT},
+#line 19 "cssproperties.gperf"
+      {"background-position-x", CSS_PROP_BACKGROUND_POSITION_X},
+#line 134 "cssproperties.gperf"
+      {"scrollbar-face-color", CSS_PROP_SCROLLBAR_FACE_COLOR},
+#line 72 "cssproperties.gperf"
+      {"-tdehtml-marquee-increment", CSS_PROP__KHTML_MARQUEE_INCREMENT},
+#line 116 "cssproperties.gperf"
+      {"word-spacing", CSS_PROP_WORD_SPACING},
+#line 111 "cssproperties.gperf"
+      {"visibility", CSS_PROP_VISIBILITY},
+#line 140 "cssproperties.gperf"
+      {"scrollbar-arrow-color", CSS_PROP_SCROLLBAR_ARROW_COLOR},
+#line 85 "cssproperties.gperf"
+      {"outline-width", CSS_PROP_OUTLINE_WIDTH},
+#line 106 "cssproperties.gperf"
+      {"text-shadow", CSS_PROP_TEXT_SHADOW},
+#line 50 "cssproperties.gperf"
+      {"display", CSS_PROP_DISPLAY},
+#line 107 "cssproperties.gperf"
+      {"text-transform", CSS_PROP_TEXT_TRANSFORM},
+#line 51 "cssproperties.gperf"
+      {"empty-cells", CSS_PROP_EMPTY_CELLS},
+#line 121 "cssproperties.gperf"
+      {"border-style", CSS_PROP_BORDER_STYLE},
+#line 32 "cssproperties.gperf"
+      {"border-top-style", CSS_PROP_BORDER_TOP_STYLE},
+#line 26 "cssproperties.gperf"
+      {"-tdehtml-border-horizontal-spacing", CSS_PROP__KHTML_BORDER_HORIZONTAL_SPACING},
+#line 33 "cssproperties.gperf"
+      {"border-right-style", CSS_PROP_BORDER_RIGHT_STYLE},
+#line 34 "cssproperties.gperf"
+      {"border-bottom-style", CSS_PROP_BORDER_BOTTOM_STYLE},
+#line 23 "cssproperties.gperf"
+      {"-tdehtml-background-size", CSS_PROP__KHTML_BACKGROUND_SIZE},
+#line 135 "cssproperties.gperf"
+      {"scrollbar-shadow-color", CSS_PROP_SCROLLBAR_SHADOW_COLOR},
+#line 129 "cssproperties.gperf"
+      {"list-style", CSS_PROP_LIST_STYLE},
+#line 101 "cssproperties.gperf"
+      {"table-layout", CSS_PROP_TABLE_LAYOUT},
+#line 54 "cssproperties.gperf"
+      {"font-size", CSS_PROP_FONT_SIZE},
+#line 86 "cssproperties.gperf"
+      {"overflow", CSS_PROP_OVERFLOW},
+#line 62 "cssproperties.gperf"
+      {"list-style-image", CSS_PROP_LIST_STYLE_IMAGE},
+#line 138 "cssproperties.gperf"
+      {"scrollbar-darkshadow-color", CSS_PROP_SCROLLBAR_DARKSHADOW_COLOR},
+#line 57 "cssproperties.gperf"
+      {"font-weight", CSS_PROP_FONT_WEIGHT},
+#line 39 "cssproperties.gperf"
+      {"border-left-width", CSS_PROP_BORDER_LEFT_WIDTH},
+#line 115 "cssproperties.gperf"
+      {"word-wrap", CSS_PROP_WORD_WRAP},
+#line 84 "cssproperties.gperf"
+      {"outline-style", CSS_PROP_OUTLINE_STYLE},
+#line 141 "cssproperties.gperf"
+      {"-tdehtml-flow-mode", CSS_PROP__KHTML_FLOW_MODE},
+#line 87 "cssproperties.gperf"
+      {"overflow-x", CSS_PROP_OVERFLOW_X},
+#line 113 "cssproperties.gperf"
+      {"widows", CSS_PROP_WIDOWS},
+#line 105 "cssproperties.gperf"
+      {"text-overflow", CSS_PROP_TEXT_OVERFLOW},
+#line 63 "cssproperties.gperf"
+      {"list-style-position", CSS_PROP_LIST_STYLE_POSITION},
+#line 20 "cssproperties.gperf"
+      {"background-position-y", CSS_PROP_BACKGROUND_POSITION_Y},
+#line 83 "cssproperties.gperf"
+      {"outline-offset", CSS_PROP_OUTLINE_OFFSET},
+#line 75 "cssproperties.gperf"
+      {"-tdehtml-marquee-style", CSS_PROP__KHTML_MARQUEE_STYLE},
+#line 55 "cssproperties.gperf"
+      {"font-style", CSS_PROP_FONT_STYLE},
+#line 35 "cssproperties.gperf"
+      {"border-left-style", CSS_PROP_BORDER_LEFT_STYLE},
+#line 64 "cssproperties.gperf"
+      {"list-style-type", CSS_PROP_LIST_STYLE_TYPE},
+#line 88 "cssproperties.gperf"
+      {"overflow-y", CSS_PROP_OVERFLOW_Y},
+#line 53 "cssproperties.gperf"
+      {"font-family", CSS_PROP_FONT_FAMILY}
+    };
+
+  static const short lookup[] =
+    {
+       -1,  -1,  -1,   0,  -1,   1,   2,  -1,  -1,   3,
+        4,   5,  -1,  -1,  -1,  -1,   6,  -1,  -1,  -1,
+        7,  -1,   8,   9,  -1,  10,  -1,  11,  -1,  -1,
+       -1,  12,  -1,  13,  14,  -1,  -1,  -1,  -1,  -1,
+       15,  16,  -1,  -1,  17,  18,  -1,  19,  20,  -1,
+       -1,  21,  22,  -1,  -1,  -1,  23,  -1,  24,  25,
+       26,  -1,  27,  28,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  29,  -1,  30,  -1,  31,  -1,  -1,  -1,
+       32,  -1,  33,  -1,  -1,  34,  -1,  35,  36,  37,
+       38,  -1,  39,  40,  41,  -1,  -1,  -1,  -1,  -1,
+       42,  43,  -1,  -1,  -1,  44,  -1,  -1,  -1,  -1,
+       -1,  45,  -1,  -1,  46,  -1,  47,  -1,  -1,  48,
+       49,  -1,  -1,  50,  -1,  51,  52,  53,  -1,  -1,
+       -1,  54,  55,  -1,  56,  -1,  -1,  -1,  -1,  -1,
+       57,  -1,  58,  -1,  59,  60,  -1,  61,  -1,  62,
+       63,  64,  -1,  -1,  -1,  -1,  -1,  65,  -1,  -1,
+       -1,  -1,  66,  -1,  67,  -1,  68,  69,  -1,  70,
+       -1,  71,  -1,  72,  73,  -1,  74,  75,  -1,  76,
+       77,  -1,  -1,  -1,  -1,  -1,  -1,  78,  -1,  79,
+       80,  -1,  81,  -1,  -1,  82,  83,  84,  -1,  85,
+       -1,  86,  87,  -1,  -1,  -1,  88,  -1,  -1,  -1,
+       89,  -1,  -1,  -1,  90,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  91,  -1,  -1,  92,  93,  -1,  -1,  -1,
+       -1,  -1,  -1,  94,  -1,  -1,  95,  96,  -1,  97,
+       -1,  98,  99,  -1,  -1,  -1, 100, 101, 102, 103,
+       -1,  -1, 104,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1, 105,  -1,  -1, 106,  -1, 107,  -1, 108,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1, 109,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1, 110,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1, 111,  -1,  -1,  -1,
+       -1, 112, 113,  -1, 114,  -1,  -1,  -1, 115,  -1,
+       -1, 116,  -1,  -1,  -1, 117,  -1,  -1,  -1,  -1,
+       -1, 118,  -1, 119,  -1,  -1,  -1,  -1,  -1, 120,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1, 121,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1, 122,  -1,  -1,  -1,  -1,  -1,
+      123,  -1,  -1,  -1,  -1, 124,  -1, 125,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1, 126,  -1,  -1,  -1,  -1,
+      127,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1, 128
+    };
+
+  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
+    {
+      register int key = hash_prop (str, len);
+
+      if (key <= MAX_HASH_VALUE && key >= 0)
+        {
+          register int index = lookup[key];
+
+          if (index >= 0)
+            {
+              register const char *s = wordlist_prop[index].name;
+
+              if (*str == *s && !strncmp (str + 1, s + 1, len - 1) && s[len] == '\0')
+                return &wordlist_prop[index];
+            }
+        }
+    }
+  return 0;
+}
+#line 143 "cssproperties.gperf"
+
+static const char * const propertyList[] = {
+"",
+"background-color", 
+"background-image", 
+"background-repeat", 
+"background-attachment", 
+"background-position", 
+"background-position-x", 
+"background-position-y", 
+"-tdehtml-background-clip", 
+"-tdehtml-background-origin", 
+"-tdehtml-background-size", 
+"border-collapse", 
+"border-spacing", 
+"-tdehtml-border-horizontal-spacing", 
+"-tdehtml-border-vertical-spacing", 
+"border-top-color", 
+"border-right-color", 
+"border-bottom-color", 
+"border-left-color", 
+"border-top-style", 
+"border-right-style", 
+"border-bottom-style", 
+"border-left-style", 
+"border-top-width", 
+"border-right-width", 
+"border-bottom-width", 
+"border-left-width", 
+"bottom", 
+"caption-side", 
+"clear", 
+"clip", 
+"color", 
+"content", 
+"counter-increment", 
+"counter-reset", 
+"cursor", 
+"direction", 
+"display", 
+"empty-cells", 
+"float", 
+"font-family", 
+"font-size", 
+"font-style", 
+"font-variant", 
+"font-weight", 
+"height", 
+"left", 
+"letter-spacing", 
+"line-height", 
+"list-style-image", 
+"list-style-position", 
+"list-style-type", 
+"margin-top", 
+"margin-right", 
+"margin-bottom", 
+"margin-left", 
+"-tdehtml-margin-start", 
+"-tdehtml-marquee", 
+"-tdehtml-marquee-direction", 
+"-tdehtml-marquee-increment", 
+"-tdehtml-marquee-repetition", 
+"-tdehtml-marquee-speed", 
+"-tdehtml-marquee-style", 
+"max-height", 
+"max-width", 
+"min-height", 
+"min-width", 
+"orphans", 
+"opacity", 
+"outline-color", 
+"outline-offset", 
+"outline-style", 
+"outline-width", 
+"overflow", 
+"overflow-x", 
+"overflow-y", 
+"padding-top", 
+"padding-right", 
+"padding-bottom", 
+"padding-left", 
+"-tdehtml-padding-start", 
+"page-break-after", 
+"page-break-before", 
+"page-break-inside", 
+"position", 
+"quotes", 
+"right", 
+"size", 
+"table-layout", 
+"text-align", 
+"text-decoration", 
+"text-indent", 
+"text-overflow", 
+"text-shadow", 
+"text-transform", 
+"top", 
+"unicode-bidi", 
+"vertical-align", 
+"visibility", 
+"white-space", 
+"widows", 
+"width", 
+"word-wrap", 
+"word-spacing", 
+"z-index", 
+"background", 
+"border", 
+"border-color", 
+"border-style", 
+"border-top", 
+"border-right", 
+"border-bottom", 
+"border-left", 
+"border-width", 
+"box-sizing", 
+"font", 
+"list-style", 
+"margin", 
+"outline", 
+"padding", 
+"scrollbar-base-color", 
+"scrollbar-face-color", 
+"scrollbar-shadow-color", 
+"scrollbar-highlight-color", 
+"scrollbar-3dlight-color", 
+"scrollbar-darkshadow-color", 
+"scrollbar-track-color", 
+"scrollbar-arrow-color", 
+"-tdehtml-flow-mode", 
+"-tdehtml-user-input", 
+    0
+};
+DOMString getPropertyName(unsigned short id)
+{
+    if(id >= CSS_PROP_TOTAL || id == 0)
+      return DOMString();
+    else
+      return DOMString(propertyList[id]);
+}
+
diff --git a/tdehtml/css/cssproperties.h b/tdehtml/css/cssproperties.h
new file mode 100644
index 000000000..be92d93d4
--- /dev/null
+++ b/tdehtml/css/cssproperties.h
@@ -0,0 +1,144 @@
+/* This file is automatically generated from cssproperties.in by makeprop, do not edit */
+/* Copyright 1998 W. Bastian */
+
+#ifndef CSSPROPERTIES_H
+#define CSSPROPERTIES_H
+
+DOM::DOMString getPropertyName(unsigned short id) KDE_NO_EXPORT;
+
+#define CSS_PROP_INVALID 0
+#define CSS_PROP_MIN 1
+#define CSS_PROP_BACKGROUND_COLOR 1
+#define CSS_PROP_BACKGROUND_IMAGE 2
+#define CSS_PROP_BACKGROUND_REPEAT 3
+#define CSS_PROP_BACKGROUND_ATTACHMENT 4
+#define CSS_PROP_BACKGROUND_POSITION 5
+#define CSS_PROP_BACKGROUND_POSITION_X 6
+#define CSS_PROP_BACKGROUND_POSITION_Y 7
+#define CSS_PROP__KHTML_BACKGROUND_CLIP 8
+#define CSS_PROP__KHTML_BACKGROUND_ORIGIN 9
+#define CSS_PROP__KHTML_BACKGROUND_SIZE 10
+#define CSS_PROP_BORDER_COLLAPSE 11
+#define CSS_PROP_BORDER_SPACING 12
+#define CSS_PROP__KHTML_BORDER_HORIZONTAL_SPACING 13
+#define CSS_PROP__KHTML_BORDER_VERTICAL_SPACING 14
+#define CSS_PROP_BORDER_TOP_COLOR 15
+#define CSS_PROP_BORDER_RIGHT_COLOR 16
+#define CSS_PROP_BORDER_BOTTOM_COLOR 17
+#define CSS_PROP_BORDER_LEFT_COLOR 18
+#define CSS_PROP_BORDER_TOP_STYLE 19
+#define CSS_PROP_BORDER_RIGHT_STYLE 20
+#define CSS_PROP_BORDER_BOTTOM_STYLE 21
+#define CSS_PROP_BORDER_LEFT_STYLE 22
+#define CSS_PROP_BORDER_TOP_WIDTH 23
+#define CSS_PROP_BORDER_RIGHT_WIDTH 24
+#define CSS_PROP_BORDER_BOTTOM_WIDTH 25
+#define CSS_PROP_BORDER_LEFT_WIDTH 26
+#define CSS_PROP_BOTTOM 27
+#define CSS_PROP_CAPTION_SIDE 28
+#define CSS_PROP_CLEAR 29
+#define CSS_PROP_CLIP 30
+#define CSS_PROP_COLOR 31
+#define CSS_PROP_CONTENT 32
+#define CSS_PROP_COUNTER_INCREMENT 33
+#define CSS_PROP_COUNTER_RESET 34
+#define CSS_PROP_CURSOR 35
+#define CSS_PROP_DIRECTION 36
+#define CSS_PROP_DISPLAY 37
+#define CSS_PROP_EMPTY_CELLS 38
+#define CSS_PROP_FLOAT 39
+#define CSS_PROP_FONT_FAMILY 40
+#define CSS_PROP_FONT_SIZE 41
+#define CSS_PROP_FONT_STYLE 42
+#define CSS_PROP_FONT_VARIANT 43
+#define CSS_PROP_FONT_WEIGHT 44
+#define CSS_PROP_HEIGHT 45
+#define CSS_PROP_LEFT 46
+#define CSS_PROP_LETTER_SPACING 47
+#define CSS_PROP_LINE_HEIGHT 48
+#define CSS_PROP_LIST_STYLE_IMAGE 49
+#define CSS_PROP_LIST_STYLE_POSITION 50
+#define CSS_PROP_LIST_STYLE_TYPE 51
+#define CSS_PROP_MARGIN_TOP 52
+#define CSS_PROP_MARGIN_RIGHT 53
+#define CSS_PROP_MARGIN_BOTTOM 54
+#define CSS_PROP_MARGIN_LEFT 55
+#define CSS_PROP__KHTML_MARGIN_START 56
+#define CSS_PROP__KHTML_MARQUEE 57
+#define CSS_PROP__KHTML_MARQUEE_DIRECTION 58
+#define CSS_PROP__KHTML_MARQUEE_INCREMENT 59
+#define CSS_PROP__KHTML_MARQUEE_REPETITION 60
+#define CSS_PROP__KHTML_MARQUEE_SPEED 61
+#define CSS_PROP__KHTML_MARQUEE_STYLE 62
+#define CSS_PROP_MAX_HEIGHT 63
+#define CSS_PROP_MAX_WIDTH 64
+#define CSS_PROP_MIN_HEIGHT 65
+#define CSS_PROP_MIN_WIDTH 66
+#define CSS_PROP_ORPHANS 67
+#define CSS_PROP_OPACITY 68
+#define CSS_PROP_OUTLINE_COLOR 69
+#define CSS_PROP_OUTLINE_OFFSET 70
+#define CSS_PROP_OUTLINE_STYLE 71
+#define CSS_PROP_OUTLINE_WIDTH 72
+#define CSS_PROP_OVERFLOW 73
+#define CSS_PROP_OVERFLOW_X 74
+#define CSS_PROP_OVERFLOW_Y 75
+#define CSS_PROP_PADDING_TOP 76
+#define CSS_PROP_PADDING_RIGHT 77
+#define CSS_PROP_PADDING_BOTTOM 78
+#define CSS_PROP_PADDING_LEFT 79
+#define CSS_PROP__KHTML_PADDING_START 80
+#define CSS_PROP_PAGE_BREAK_AFTER 81
+#define CSS_PROP_PAGE_BREAK_BEFORE 82
+#define CSS_PROP_PAGE_BREAK_INSIDE 83
+#define CSS_PROP_POSITION 84
+#define CSS_PROP_QUOTES 85
+#define CSS_PROP_RIGHT 86
+#define CSS_PROP_SIZE 87
+#define CSS_PROP_TABLE_LAYOUT 88
+#define CSS_PROP_TEXT_ALIGN 89
+#define CSS_PROP_TEXT_DECORATION 90
+#define CSS_PROP_TEXT_INDENT 91
+#define CSS_PROP_TEXT_OVERFLOW 92
+#define CSS_PROP_TEXT_SHADOW 93
+#define CSS_PROP_TEXT_TRANSFORM 94
+#define CSS_PROP_TOP 95
+#define CSS_PROP_UNICODE_BIDI 96
+#define CSS_PROP_VERTICAL_ALIGN 97
+#define CSS_PROP_VISIBILITY 98
+#define CSS_PROP_WHITE_SPACE 99
+#define CSS_PROP_WIDOWS 100
+#define CSS_PROP_WIDTH 101
+#define CSS_PROP_WORD_WRAP 102
+#define CSS_PROP_WORD_SPACING 103
+#define CSS_PROP_Z_INDEX 104
+#define CSS_PROP_BACKGROUND 105
+#define CSS_PROP_BORDER 106
+#define CSS_PROP_BORDER_COLOR 107
+#define CSS_PROP_BORDER_STYLE 108
+#define CSS_PROP_BORDER_TOP 109
+#define CSS_PROP_BORDER_RIGHT 110
+#define CSS_PROP_BORDER_BOTTOM 111
+#define CSS_PROP_BORDER_LEFT 112
+#define CSS_PROP_BORDER_WIDTH 113
+#define CSS_PROP_BOX_SIZING 114
+#define CSS_PROP_FONT 115
+#define CSS_PROP_LIST_STYLE 116
+#define CSS_PROP_MARGIN 117
+#define CSS_PROP_OUTLINE 118
+#define CSS_PROP_PADDING 119
+#define CSS_PROP_SCROLLBAR_BASE_COLOR 120
+#define CSS_PROP_SCROLLBAR_FACE_COLOR 121
+#define CSS_PROP_SCROLLBAR_SHADOW_COLOR 122
+#define CSS_PROP_SCROLLBAR_HIGHLIGHT_COLOR 123
+#define CSS_PROP_SCROLLBAR_3DLIGHT_COLOR 124
+#define CSS_PROP_SCROLLBAR_DARKSHADOW_COLOR 125
+#define CSS_PROP_SCROLLBAR_TRACK_COLOR 126
+#define CSS_PROP_SCROLLBAR_ARROW_COLOR 127
+#define CSS_PROP__KHTML_FLOW_MODE 128
+#define CSS_PROP__KHTML_USER_INPUT 129
+
+#define CSS_PROP_MAX CSS_PROP_Z_INDEX
+#define CSS_PROP_TOTAL 130
+#endif
+
diff --git a/tdehtml/css/cssproperties.in b/tdehtml/css/cssproperties.in
new file mode 100644
index 000000000..27e452322
--- /dev/null
+++ b/tdehtml/css/cssproperties.in
@@ -0,0 +1,148 @@
+#
+# all valid CSS2 properties.
+#
+# aural properties are commented out, as we don't support them anyway.
+#
+# some properties are used in tdehtml, but are not part of CSS. They are used to get
+# HTML4 compatibility in the rendering engine.
+#
+# Mircosoft extensions are documented here:
+# http://msdn.microsoft.com/workshop/author/css/reference/attributes.asp
+#
+# CSS_PROP_BACKGROUND_COLOR:
+#
+background-color
+background-image
+background-repeat
+background-attachment
+background-position
+# IE Extensions
+background-position-x
+background-position-y
+# CSS3 Extensions
+-tdehtml-background-clip
+-tdehtml-background-origin
+-tdehtml-background-size
+
+border-collapse
+border-spacing
+-tdehtml-border-horizontal-spacing
+-tdehtml-border-vertical-spacing
+border-top-color
+border-right-color
+border-bottom-color
+border-left-color
+border-top-style
+border-right-style
+border-bottom-style
+border-left-style
+border-top-width
+border-right-width
+border-bottom-width
+border-left-width
+bottom
+caption-side
+clear
+clip
+color
+content
+counter-increment
+counter-reset
+cursor
+direction
+display
+empty-cells
+float
+font-family
+font-size
+font-style
+font-variant
+font-weight
+height
+left
+letter-spacing
+line-height
+list-style-image
+list-style-position
+list-style-type
+margin-top
+margin-right
+margin-bottom
+margin-left
+-tdehtml-margin-start
+-tdehtml-marquee
+-tdehtml-marquee-direction
+-tdehtml-marquee-increment
+-tdehtml-marquee-repetition
+-tdehtml-marquee-speed
+-tdehtml-marquee-style
+max-height
+max-width
+min-height
+min-width
+orphans
+opacity
+outline-color
+outline-offset
+outline-style
+outline-width
+overflow
+overflow-x
+overflow-y
+padding-top
+padding-right
+padding-bottom
+padding-left
+-tdehtml-padding-start
+#page
+page-break-after
+page-break-before
+page-break-inside
+position
+quotes
+right
+size
+table-layout
+text-align
+text-decoration
+text-indent
+text-overflow
+text-shadow
+text-transform
+top
+unicode-bidi
+vertical-align
+visibility
+white-space
+widows
+width
+word-wrap
+word-spacing
+z-index
+background
+border
+border-color
+border-style
+border-top
+border-right
+border-bottom
+border-left
+border-width
+box-sizing
+font
+list-style
+margin
+outline
+padding
+# some more IE extensions
+scrollbar-base-color
+scrollbar-face-color
+scrollbar-shadow-color
+scrollbar-highlight-color
+scrollbar-3dlight-color
+scrollbar-darkshadow-color
+scrollbar-track-color
+scrollbar-arrow-color
+# tdehtml internals
+-tdehtml-flow-mode
+-tdehtml-user-input
diff --git a/tdehtml/css/cssstyleselector.cpp b/tdehtml/css/cssstyleselector.cpp
new file mode 100644
index 000000000..f2c5703c1
--- /dev/null
+++ b/tdehtml/css/cssstyleselector.cpp
@@ -0,0 +1,4217 @@
+/**
+ * This file is part of the CSS implementation for KDE.
+ *
+ * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org)
+ *           (C) 2003-2004 Apple Computer, Inc.
+ *           (C) 2004-2006 Allan Sandfeld Jensen (kde@carewolf.com)
+ *           (C) 2004 Germain Garand (germain@ebooksfrance.org)
+ *           (C) 2005, 2006 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 "css/cssstyleselector.h"
+#include "rendering/render_style.h"
+#include "css/css_stylesheetimpl.h"
+#include "css/css_ruleimpl.h"
+#include "css/css_valueimpl.h"
+#include "css/csshelper.h"
+#include "rendering/render_object.h"
+#include "html/html_documentimpl.h"
+#include "html/html_elementimpl.h"
+#include "xml/dom_elementimpl.h"
+#include "xml/dom_restyler.h"
+#include "dom/css_rule.h"
+#include "dom/css_value.h"
+#include "tdehtml_factory.h"
+#include "tdehtmlpart_p.h"
+using namespace tdehtml;
+using namespace DOM;
+
+#include "css/cssproperties.h"
+#include "css/cssvalues.h"
+
+#include "misc/tdehtmllayout.h"
+#include "tdehtml_settings.h"
+#include "misc/htmlhashes.h"
+#include "misc/helper.h"
+#include "misc/loader.h"
+
+#include "rendering/font.h"
+
+#include "tdehtmlview.h"
+#include "tdehtml_part.h"
+
+#include <kstandarddirs.h>
+#include <kcharsets.h>
+#include <kglobal.h>
+#include <kconfig.h>
+#include <tqfile.h>
+#include <tqvaluelist.h>
+#include <tqstring.h>
+#include <tqtooltip.h>
+#include <kdebug.h>
+#include <kurl.h>
+#include <assert.h>
+#include <tqpaintdevicemetrics.h>
+#include <stdlib.h>
+
+#define HANDLE_INHERIT(prop, Prop) \
+if (isInherit) \
+{\
+    style->set##Prop(parentStyle->prop());\
+    return;\
+}
+
+#define HANDLE_INHERIT_AND_INITIAL(prop, Prop) \
+HANDLE_INHERIT(prop, Prop) \
+else if (isInitial) \
+{\
+    style->set##Prop(RenderStyle::initial##Prop());\
+    return;\
+}
+
+#define HANDLE_INHERIT_AND_INITIAL_WITH_VALUE(prop, Prop, Value) \
+HANDLE_INHERIT(prop, Prop) \
+else if (isInitial) \
+{\
+    style->set##Prop(RenderStyle::initial##Value());\
+    return;\
+}
+
+#define HANDLE_BACKGROUND_INHERIT_AND_INITIAL(prop, Prop) \
+if (isInherit) { \
+    BackgroundLayer* currChild = style->accessBackgroundLayers(); \
+    BackgroundLayer* prevChild = 0; \
+    const BackgroundLayer* currParent = parentStyle->backgroundLayers(); \
+    while (currParent && currParent->is##Prop##Set()) { \
+        if (!currChild) { \
+            /* Need to make a new layer.*/ \
+            currChild = new BackgroundLayer(); \
+            prevChild->setNext(currChild); \
+        } \
+        currChild->set##Prop(currParent->prop()); \
+        prevChild = currChild; \
+        currChild = prevChild->next(); \
+        currParent = currParent->next(); \
+    } \
+    \
+    while (currChild) { \
+        /* Reset any remaining layers to not have the property set. */ \
+        currChild->clear##Prop(); \
+        currChild = currChild->next(); \
+    } \
+    return; \
+} \
+if (isInitial) { \
+    BackgroundLayer* currChild = style->accessBackgroundLayers(); \
+    currChild->set##Prop(RenderStyle::initial##Prop()); \
+    for (currChild = currChild->next(); currChild; currChild = currChild->next()) \
+        currChild->clear##Prop(); \
+    return; \
+}
+
+#define HANDLE_BACKGROUND_VALUE(prop, Prop, value) { \
+HANDLE_BACKGROUND_INHERIT_AND_INITIAL(prop, Prop) \
+if (!value->isPrimitiveValue() && !value->isValueList()) \
+    return; \
+BackgroundLayer* currChild = style->accessBackgroundLayers(); \
+BackgroundLayer* prevChild = 0; \
+if (value->isPrimitiveValue()) { \
+    map##Prop(currChild, value); \
+    currChild = currChild->next(); \
+} \
+else { \
+    /* Walk each value and put it into a layer, creating new layers as needed. */ \
+    CSSValueListImpl* valueList = static_cast<CSSValueListImpl*>(value); \
+    for (unsigned int i = 0; i < valueList->length(); i++) { \
+        if (!currChild) { \
+            /* Need to make a new layer to hold this value */ \
+            currChild = new BackgroundLayer(); \
+            prevChild->setNext(currChild); \
+        } \
+        map##Prop(currChild, valueList->item(i)); \
+        prevChild = currChild; \
+        currChild = currChild->next(); \
+    } \
+} \
+while (currChild) { \
+    /* Reset all remaining layers to not have the property set. */ \
+    currChild->clear##Prop(); \
+    currChild = currChild->next(); \
+} }
+
+#define HANDLE_INHERIT_COND(propID, prop, Prop) \
+if (id == propID) \
+{\
+    style->set##Prop(parentStyle->prop());\
+    return;\
+}
+
+#define HANDLE_INITIAL_COND(propID, Prop) \
+if (id == propID) \
+{\
+    style->set##Prop(RenderStyle::initial##Prop());\
+    return;\
+}
+
+#define HANDLE_INITIAL_COND_WITH_VALUE(propID, Prop, Value) \
+if (id == propID) \
+{\
+    style->set##Prop(RenderStyle::initial##Value());\
+    return;\
+}
+
+#define HANDLE_INHERIT_ON_INHERITED_PROPERTY(prop, Prop) \
+if (isInherit) \
+{\
+    style->set##Prop(parentStyle->prop());\
+    return;\
+}
+
+#define HANDLE_INITIAL(prop, Prop) \
+if (isInitial) \
+{\
+    style->set##Prop(RenderStyle::initial##Prop());\
+    return;\
+}
+
+#define HANDLE_INITIAL_AND_INHERIT_ON_INHERITED_PROPERTY(prop, Prop) \
+HANDLE_INITIAL(prop, Prop) \
+else \
+HANDLE_INHERIT_ON_INHERITED_PROPERTY(prop, Prop)
+
+
+namespace tdehtml {
+
+CSSStyleSelectorList *CSSStyleSelector::s_defaultStyle;
+CSSStyleSelectorList *CSSStyleSelector::s_defaultQuirksStyle;
+CSSStyleSelectorList *CSSStyleSelector::s_defaultPrintStyle;
+CSSStyleSheetImpl *CSSStyleSelector::s_defaultSheet;
+RenderStyle* CSSStyleSelector::styleNotYetAvailable;
+CSSStyleSheetImpl *CSSStyleSelector::s_quirksSheet;
+
+enum PseudoState { PseudoUnknown, PseudoNone, PseudoLink, PseudoVisited};
+static PseudoState pseudoState;
+
+
+CSSStyleSelector::CSSStyleSelector( DocumentImpl* doc, TQString userStyleSheet, StyleSheetListImpl *styleSheets,
+                                    const KURL &url, bool _strictParsing )
+{
+    KHTMLView* view = doc->view();
+
+    init(view ? view->part()->settings() : 0, doc);
+
+    strictParsing = _strictParsing;
+    m_medium = view ? view->mediaType() : TQString("all");
+
+    selectors = 0;
+    selectorCache = 0;
+    properties = 0;
+    userStyle = 0;
+    userSheet = 0;
+    paintDeviceMetrics = doc->paintDeviceMetrics();
+
+    if(paintDeviceMetrics) // this may be null, not everyone uses tdehtmlview (Niko)
+        computeFontSizes(paintDeviceMetrics, view ? view->part()->zoomFactor() : 100);
+
+    if ( !userStyleSheet.isEmpty() ) {
+        userSheet = new DOM::CSSStyleSheetImpl(doc);
+        userSheet->parseString( DOMString( userStyleSheet ) );
+
+        userStyle = new CSSStyleSelectorList();
+        userStyle->append( userSheet, m_medium );
+    }
+
+    // add stylesheets from document
+    authorStyle = new CSSStyleSelectorList();
+
+
+    TQPtrListIterator<StyleSheetImpl> it( styleSheets->styleSheets );
+    for ( ; it.current(); ++it ) {
+        if ( it.current()->isCSSStyleSheet() && !it.current()->disabled()) {
+            authorStyle->append( static_cast<CSSStyleSheetImpl*>( it.current() ), m_medium );
+        }
+    }
+
+    buildLists();
+
+    //kdDebug( 6080 ) << "number of style sheets in document " << authorStyleSheets.count() << endl;
+    //kdDebug( 6080 ) << "CSSStyleSelector: author style has " << authorStyle->count() << " elements"<< endl;
+
+    KURL u = url;
+
+    u.setQuery( TQString::null );
+    u.setRef( TQString::null );
+    encodedurl.file = u.url();
+    int pos = encodedurl.file.findRev('/');
+    encodedurl.path = encodedurl.file;
+    if ( pos > 0 ) {
+	encodedurl.path.truncate( pos );
+	encodedurl.path += '/';
+    }
+    u.setPath( TQString::null );
+    encodedurl.host = u.url();
+
+    //kdDebug() << "CSSStyleSelector::CSSStyleSelector encoded url " << encodedurl.path << endl;
+}
+
+CSSStyleSelector::CSSStyleSelector( CSSStyleSheetImpl *sheet )
+{
+    init(0L, 0L);
+
+    KHTMLView *view = sheet->doc()->view();
+    m_medium = view ? view->mediaType() : "screen";
+
+    authorStyle = new CSSStyleSelectorList();
+    authorStyle->append( sheet, m_medium );
+}
+
+void CSSStyleSelector::init(const KHTMLSettings* _settings, DocumentImpl* doc)
+{
+    element = 0;
+    settings = _settings;
+    paintDeviceMetrics = 0;
+    propsToApply = (CSSOrderedProperty **)malloc(128*sizeof(CSSOrderedProperty *));
+    pseudoProps = (CSSOrderedProperty **)malloc(128*sizeof(CSSOrderedProperty *));
+    propsToApplySize = 128;
+    pseudoPropsSize = 128;
+    if(!s_defaultStyle) loadDefaultStyle(settings, doc);
+
+    defaultStyle = s_defaultStyle;
+    defaultPrintStyle = s_defaultPrintStyle;
+    defaultQuirksStyle = s_defaultQuirksStyle;
+}
+
+CSSStyleSelector::~CSSStyleSelector()
+{
+    clearLists();
+    delete authorStyle;
+    delete userStyle;
+    delete userSheet;
+    free(propsToApply);
+    free(pseudoProps);
+}
+
+void CSSStyleSelector::addSheet( CSSStyleSheetImpl *sheet )
+{
+    KHTMLView *view = sheet->doc()->view();
+    m_medium = view ? view->mediaType() : "screen";
+    authorStyle->append( sheet, m_medium );
+}
+
+void CSSStyleSelector::loadDefaultStyle(const KHTMLSettings *s, DocumentImpl *doc)
+{
+    if(s_defaultStyle) return;
+
+    {
+	TQFile f(locate( "data", "tdehtml/css/html4.css" ) );
+	f.open(IO_ReadOnly);
+
+	TQCString file( f.size()+1 );
+	int readbytes = f.readBlock( file.data(), f.size() );
+	f.close();
+	if ( readbytes >= 0 )
+	    file[readbytes] = '\0';
+
+	TQString style = TQString::fromLatin1( file.data() );
+	if(s)
+	    style += s->settingsToCSS();
+	DOMString str(style);
+
+	s_defaultSheet = new DOM::CSSStyleSheetImpl(doc);
+	s_defaultSheet->parseString( str );
+
+	// Collect only strict-mode rules.
+	s_defaultStyle = new CSSStyleSelectorList();
+	s_defaultStyle->append( s_defaultSheet, "screen" );
+
+	s_defaultPrintStyle = new CSSStyleSelectorList();
+	s_defaultPrintStyle->append( s_defaultSheet, "print" );
+    }
+    {
+	TQFile f(locate( "data", "tdehtml/css/quirks.css" ) );
+	f.open(IO_ReadOnly);
+
+	TQCString file( f.size()+1 );
+	int readbytes = f.readBlock( file.data(), f.size() );
+	f.close();
+	if ( readbytes >= 0 )
+	    file[readbytes] = '\0';
+
+	TQString style = TQString::fromLatin1( file.data() );
+	DOMString str(style);
+
+	s_quirksSheet = new DOM::CSSStyleSheetImpl(doc);
+	s_quirksSheet->parseString( str );
+
+	// Collect only quirks-mode rules.
+	s_defaultQuirksStyle = new CSSStyleSelectorList();
+	s_defaultQuirksStyle->append( s_quirksSheet, "screen" );
+    }
+
+    //kdDebug() << "CSSStyleSelector: default style has " << defaultStyle->count() << " elements"<< endl;
+}
+
+void CSSStyleSelector::clear()
+{
+    delete s_defaultStyle;
+    delete s_defaultQuirksStyle;
+    delete s_defaultPrintStyle;
+    delete s_defaultSheet;
+    delete styleNotYetAvailable;
+    s_defaultStyle = 0;
+    s_defaultQuirksStyle = 0;
+    s_defaultPrintStyle = 0;
+    s_defaultSheet = 0;
+    styleNotYetAvailable = 0;
+}
+
+void CSSStyleSelector::reparseConfiguration()
+{
+    // nice leak, but best we can do right now. hopefully its only rare.
+    s_defaultStyle = 0;
+    s_defaultQuirksStyle = 0;
+    s_defaultPrintStyle = 0;
+    s_defaultSheet = 0;
+}
+
+#define MAXFONTSIZES 8
+
+void CSSStyleSelector::computeFontSizes(TQPaintDeviceMetrics* paintDeviceMetrics,  int zoomFactor)
+{
+    computeFontSizesFor(paintDeviceMetrics, zoomFactor, m_fontSizes, false);
+    computeFontSizesFor(paintDeviceMetrics, zoomFactor, m_fixedFontSizes, true);
+}
+
+void CSSStyleSelector::computeFontSizesFor(TQPaintDeviceMetrics* paintDeviceMetrics, int zoomFactor, TQValueVector<int>& fontSizes, bool isFixed)
+{
+#ifdef APPLE_CHANGES
+    // We don't want to scale the settings by the dpi.
+    const float toPix = 1;
+#else
+    Q_UNUSED( isFixed );
+
+    // ### get rid of float / double
+    float toPix = paintDeviceMetrics->logicalDpiY()/72.;
+    if (toPix  < 96./72.) toPix = 96./72.;
+#endif // ######### fix isFixed code again.
+
+    fontSizes.resize( MAXFONTSIZES );
+    float scale = 1.0;
+    static const float fontFactors[] =      {3./5., 3./4., 8./9., 1., 6./5., 3./2., 2., 3.};
+    static const float smallFontFactors[] = {3./4., 5./6., 8./9., 1., 6./5., 3./2., 2., 3.};
+    float mediumFontSize, minFontSize, factor;
+    if (!tdehtml::printpainter) {
+        scale *= zoomFactor / 100.0;
+#ifdef APPLE_CHANGES
+	if (isFixed)
+	    mediumFontSize = settings->mediumFixedFontSize() * toPix;
+	else
+#endif
+	    mediumFontSize = settings->mediumFontSize() * toPix;
+        minFontSize = settings->minFontSize() * toPix;
+    }
+    else {
+        // ## depending on something / configurable ?
+        mediumFontSize = 12;
+        minFontSize = 6;
+    }
+    const float* factors = scale*mediumFontSize >= 12.5 ? fontFactors : smallFontFactors;
+    for ( int i = 0; i < MAXFONTSIZES; i++ ) {
+        factor = scale*factors[i];
+        fontSizes[i] = int(KMAX( mediumFontSize*factor +.5f, minFontSize));
+        //kdDebug( 6080 ) << "index: " << i << " factor: " << factors[i] << " font pix size: " << int(KMAX( mediumFontSize*factor +.5f, minFontSize)) << endl;
+    }
+}
+
+#undef MAXFONTSIZES
+
+static inline void bubbleSort( CSSOrderedProperty **b, CSSOrderedProperty **e )
+{
+    while( b < e ) {
+	bool swapped = false;
+        CSSOrderedProperty **y = e+1;
+	CSSOrderedProperty **x = e;
+        CSSOrderedProperty **swappedPos = 0;
+	do {
+	    if ( !((**(--x)) < (**(--y))) ) {
+		swapped = true;
+                swappedPos = x;
+                CSSOrderedProperty *tmp = *y;
+                *y = *x;
+                *x = tmp;
+	    }
+	} while( x != b );
+	if ( !swapped ) break;
+        b = swappedPos + 1;
+    }
+}
+
+RenderStyle *CSSStyleSelector::styleForElement(ElementImpl *e)
+{
+    if (!e->getDocument()->haveStylesheetsLoaded() || !e->getDocument()->view()) {
+        if (!styleNotYetAvailable) {
+            styleNotYetAvailable = new RenderStyle();
+            styleNotYetAvailable->setDisplay(NONE);
+            styleNotYetAvailable->ref();
+        }
+        return styleNotYetAvailable;
+    }
+
+    // set some variables we will need
+    pseudoState = PseudoUnknown;
+
+    element = e;
+    parentNode = e->parentNode();
+    parentStyle = ( parentNode && parentNode->renderer()) ? parentNode->renderer()->style() : 0;
+    view = element->getDocument()->view();
+    part = view->part();
+    settings = part->settings();
+    paintDeviceMetrics = element->getDocument()->paintDeviceMetrics();
+
+    // reset dynamic DOM dependencies
+    e->getDocument()->dynamicDomRestyler().resetDependencies(e);
+
+    style = new RenderStyle();
+    if( parentStyle )
+        style->inheritFrom( parentStyle );
+    else
+	parentStyle = style;
+
+    unsigned int numPropsToApply = 0;
+    unsigned int numPseudoProps = 0;
+
+    // try to sort out most style rules as early as possible.
+    TQ_UINT16 cssTagId = localNamePart(element->id());
+    int smatch = 0;
+    int schecked = 0;
+
+    for ( unsigned int i = 0; i < selectors_size; i++ ) {
+	TQ_UINT16 tag = localNamePart(selectors[i]->tag);
+	if ( cssTagId == tag || tag == anyLocalName ) {
+	    ++schecked;
+
+	    checkSelector( i, e );
+
+	    if ( selectorCache[i].state == Applies ) {
+		++smatch;
+
+// 		tqDebug("adding property" );
+		for ( unsigned int p = 0; p < selectorCache[i].props_size; p += 2 )
+		    for ( unsigned int j = 0; j < (unsigned int )selectorCache[i].props[p+1]; ++j ) {
+                        if (numPropsToApply >= propsToApplySize ) {
+                            propsToApplySize *= 2;
+			    propsToApply = (CSSOrderedProperty **)realloc( propsToApply, propsToApplySize*sizeof( CSSOrderedProperty * ) );
+			}
+			propsToApply[numPropsToApply++] = properties[selectorCache[i].props[p]+j];
+		    }
+	    } else if ( selectorCache[i].state == AppliesPseudo ) {
+		for ( unsigned int p = 0; p < selectorCache[i].props_size; p += 2 )
+		    for ( unsigned int j = 0; j < (unsigned int) selectorCache[i].props[p+1]; ++j ) {
+                        if (numPseudoProps >= pseudoPropsSize ) {
+                            pseudoPropsSize *= 2;
+			    pseudoProps = (CSSOrderedProperty **)realloc( pseudoProps, pseudoPropsSize*sizeof( CSSOrderedProperty * ) );
+			}
+			pseudoProps[numPseudoProps++] = properties[selectorCache[i].props[p]+j];
+			properties[selectorCache[i].props[p]+j]->pseudoId = (RenderStyle::PseudoId) selectors[i]->pseudoId;
+		    }
+	    }
+	}
+	else
+	    selectorCache[i].state = Invalid;
+
+    }
+
+    // inline style declarations, after all others. non css hints
+    // count as author rules, and come before all other style sheets, see hack in append()
+    numPropsToApply = addInlineDeclarations( e, e->m_styleDecls, numPropsToApply );
+
+//     tqDebug( "styleForElement( %s )", e->tagName().string().latin1() );
+//     tqDebug( "%d selectors, %d checked,  %d match,  %d properties ( of %d )",
+// 	    selectors_size, schecked, smatch, numPropsToApply, properties_size );
+
+    bubbleSort( propsToApply, propsToApply+numPropsToApply-1 );
+    bubbleSort( pseudoProps, pseudoProps+numPseudoProps-1 );
+
+    // we can't apply style rules without a view() and a part. This
+    // tends to happen on delayed destruction of widget Renderobjects
+    if ( part ) {
+        fontDirty = false;
+
+        if (numPropsToApply ) {
+            CSSStyleSelector::style = style;
+            for (unsigned int i = 0; i < numPropsToApply; ++i) {
+		if ( fontDirty && propsToApply[i]->priority >= (1 << 30) ) {
+		    // we are past the font properties, time to update to the
+		    // correct font
+#ifdef APPLE_CHANGES
+		    checkForGenericFamilyChange(style, parentStyle);
+#endif
+		    CSSStyleSelector::style->htmlFont().update( paintDeviceMetrics );
+		    fontDirty = false;
+		}
+		DOM::CSSProperty *prop = propsToApply[i]->prop;
+//		if (prop->m_id == CSS_PROP__KONQ_USER_INPUT) kdDebug(6080) << "El: "<<e->nodeName().string() << " user-input: "<<((CSSPrimitiveValueImpl *)prop->value())->getIdent() << endl;
+//		if (prop->m_id == CSS_PROP_TEXT_TRANSFORM) kdDebug(6080) << "El: "<<e->nodeName().string() << endl;
+                applyRule( prop->m_id, prop->value() );
+	    }
+	    if ( fontDirty ) {
+#ifdef APPLE_CHANGES
+	        checkForGenericFamilyChange(style, parentStyle);
+#endif
+		CSSStyleSelector::style->htmlFont().update( paintDeviceMetrics );
+            }
+        }
+
+        // Clean up our style object's display and text decorations (among other fixups).
+        adjustRenderStyle(style, e);
+
+        if ( numPseudoProps ) {
+	    fontDirty = false;
+            //tqDebug("%d applying %d pseudo props", e->cssTagId(), pseudoProps->count() );
+            for (unsigned int i = 0; i < numPseudoProps; ++i) {
+		if ( fontDirty && pseudoProps[i]->priority >= (1 << 30) ) {
+		    // we are past the font properties, time to update to the
+		    // correct font
+		    //We have to do this for all pseudo styles
+		    RenderStyle *pseudoStyle = style->pseudoStyle;
+		    while ( pseudoStyle ) {
+			pseudoStyle->htmlFont().update( paintDeviceMetrics );
+			pseudoStyle = pseudoStyle->pseudoStyle;
+		    }
+		    fontDirty = false;
+		}
+
+                RenderStyle *pseudoStyle;
+                pseudoStyle = style->getPseudoStyle(pseudoProps[i]->pseudoId);
+                if (!pseudoStyle)
+                {
+                    pseudoStyle = style->addPseudoStyle(pseudoProps[i]->pseudoId);
+                    if (pseudoStyle)
+                        pseudoStyle->inheritFrom( style );
+                }
+
+                RenderStyle* oldStyle = style;
+                RenderStyle* oldParentStyle = parentStyle;
+                parentStyle = style;
+		style = pseudoStyle;
+                if ( pseudoStyle ) {
+		    DOM::CSSProperty *prop = pseudoProps[i]->prop;
+		    applyRule( prop->m_id, prop->value() );
+		}
+                style = oldStyle;
+                parentStyle = oldParentStyle;
+            }
+
+	    if ( fontDirty ) {
+		RenderStyle *pseudoStyle = style->pseudoStyle;
+		while ( pseudoStyle ) {
+		    pseudoStyle->htmlFont().update( paintDeviceMetrics );
+		    pseudoStyle = pseudoStyle->pseudoStyle;
+		}
+	    }
+        }
+    }
+
+    // Now adjust all our pseudo-styles.
+    RenderStyle *pseudoStyle = style->pseudoStyle;
+    while (pseudoStyle) {
+        adjustRenderStyle(pseudoStyle, 0);
+        pseudoStyle = pseudoStyle->pseudoStyle;
+    }
+
+    // Now return the style.
+    return style;
+}
+
+void CSSStyleSelector::adjustRenderStyle(RenderStyle* style, DOM::ElementImpl *e)
+{
+     // Cache our original display.
+     style->setOriginalDisplay(style->display());
+
+    if (style->display() != NONE) {
+        // If we have a <td> that specifies a float property, in quirks mode we just drop the float
+        // property.
+        // Sites also commonly use display:inline/block on <td>s and <table>s.  In quirks mode we force
+        // these tags to retain their display types.
+        if (!strictParsing && e) {
+            if (e->id() == ID_TD) {
+                style->setDisplay(TABLE_CELL);
+                style->setFloating(FNONE);
+            }
+            else if (e->id() == ID_TABLE)
+                style->setDisplay(style->isDisplayInlineType() ? INLINE_TABLE : TABLE);
+        }
+
+        // Table headers with a text-align of auto will change the text-align to center.
+        if (e && e->id() == ID_TH && style->textAlign() == TAAUTO)
+            style->setTextAlign(CENTER);
+
+        // Mutate the display to BLOCK or TABLE for certain cases, e.g., if someone attempts to
+        // position or float an inline, compact, or run-in.  Cache the original display, since it
+        // may be needed for positioned elements that have to compute their static normal flow
+        // positions.  We also force inline-level roots to be block-level.
+        if (style->display() != BLOCK && style->display() != TABLE /*&& style->display() != BOX*/ &&
+            (style->position() == ABSOLUTE || style->position() == FIXED || style->floating() != FNONE ||
+             (e && e->getDocument()->documentElement() == e))) {
+             if (style->display() == INLINE_TABLE)
+                 style->setDisplay(TABLE);
+//             else if (style->display() == INLINE_BOX)
+//                 style->setDisplay(BOX);
+            else if (style->display() == LIST_ITEM) {
+                // It is a WinIE bug that floated list items lose their bullets, so we'll emulate the quirk,
+                // but only in quirks mode.
+                if (!strictParsing && style->floating() != FNONE)
+                    style->setDisplay(BLOCK);
+            }
+            else
+                style->setDisplay(BLOCK);
+        }
+
+        // After performing the display mutation, check our position.  We do not honor position:relative on
+        // table rows and some other table displays. This is undefined behaviour in CSS2.1 (cf. 9.3.1)
+        if (style->position() == RELATIVE) {
+            switch (style->display()) {
+              case TABLE_ROW_GROUP:
+              case TABLE_HEADER_GROUP:
+              case TABLE_FOOTER_GROUP:
+              case TABLE_ROW:
+                style->setPosition(STATIC);
+              default:
+                break;
+            }
+        }
+    }
+
+    // Frames and framesets never honor position:relative or position:absolute.  This is necessary to
+    // fix a crash where a site tries to position these objects.
+    if ( e ) {
+        // ignore display: none for <frame>
+        if ( e->id() == ID_FRAME ) {
+            style->setPosition( STATIC );
+            style->setDisplay( BLOCK );
+        }
+        else if ( e->id() == ID_FRAMESET ) {
+            style->setPosition( STATIC );
+        }
+    }
+
+    // Finally update our text decorations in effect, but don't allow text-decoration to percolate through
+    // tables, inline blocks, inline tables, or run-ins.
+    if (style->display() == TABLE || style->display() == INLINE_TABLE || style->display() == RUN_IN
+        || style->display() == INLINE_BLOCK /*|| style->display() == INLINE_BOX*/)
+        style->setTextDecorationsInEffect(style->textDecoration());
+    else
+        style->addToTextDecorationsInEffect(style->textDecoration());
+
+    // If either overflow value is not visible, change to auto.
+    if (style->overflowX() == OMARQUEE && style->overflowY() != OMARQUEE)
+        style->setOverflowY(OMARQUEE);
+    else if (style->overflowY() == OMARQUEE && style->overflowX() != OMARQUEE)
+        style->setOverflowX(OMARQUEE);
+    else if (style->overflowX() == OVISIBLE && style->overflowY() != OVISIBLE)
+        style->setOverflowX(OAUTO);
+    else if (style->overflowY() == OVISIBLE && style->overflowX() != OVISIBLE)
+        style->setOverflowY(OAUTO);
+
+    // Table rows, sections and the table itself will support overflow:hidden and will ignore scroll/auto.
+    // FIXME: Eventually table sections will support auto and scroll.
+    if (style->display() == TABLE || style->display() == INLINE_TABLE ||
+        style->display() == TABLE_ROW_GROUP || style->display() == TABLE_ROW) {
+        if (style->overflowX() != OVISIBLE && style->overflowX() != OHIDDEN)
+            style->setOverflowX(OVISIBLE);
+        if (style->overflowY() != OVISIBLE && style->overflowY() != OHIDDEN)
+            style->setOverflowY(OVISIBLE);
+    }
+
+    // Cull out any useless layers and also repeat patterns into additional layers.
+    style->adjustBackgroundLayers();
+
+    // Only use slow repaints if we actually have a background image.
+    // FIXME: We only need to invalidate the fixed regions when scrolling.  It's total overkill to
+    // prevent the entire view from blitting on a scroll.
+    if (style->hasFixedBackgroundImage() && view)
+        view->useSlowRepaints();
+}
+
+unsigned int CSSStyleSelector::addInlineDeclarations(DOM::ElementImpl* e,
+                                                     DOM::CSSStyleDeclarationImpl *decl,
+                                                     unsigned int numProps)
+{
+    CSSStyleDeclarationImpl* addDecls = 0;
+#ifdef APPLE_CHANGES
+    if (e->id() == ID_TD || e->id() == ID_TH)     // For now only TableCellElement implements the
+        addDecls = e->getAdditionalStyleDecls();  // virtual function for shared cell rules.
+#else
+    Q_UNUSED( e );
+#endif
+
+    if (!decl && !addDecls)
+        return numProps;
+
+    TQPtrList<CSSProperty>* values = decl ? decl->values() : 0;
+    TQPtrList<CSSProperty>* addValues = addDecls ? addDecls->values() : 0;
+    if (!values && !addValues)
+        return numProps;
+
+    int firstLen = values ? values->count() : 0;
+    int secondLen = addValues ? addValues->count() : 0;
+    int totalLen = firstLen + secondLen;
+
+    if (inlineProps.size() < (uint)totalLen)
+        inlineProps.resize(totalLen + 1);
+
+    if (numProps + totalLen >= propsToApplySize ) {
+        propsToApplySize += propsToApplySize;
+        propsToApply = (CSSOrderedProperty **)realloc( propsToApply, propsToApplySize*sizeof( CSSOrderedProperty * ) );
+    }
+
+    CSSOrderedProperty *array = (CSSOrderedProperty *)inlineProps.data();
+    for(int i = 0; i < totalLen; i++)
+    {
+        if (i == firstLen)
+            values = addValues;
+
+        CSSProperty *prop = values->at(i >= firstLen ? i - firstLen : i);
+	Source source = Inline;
+
+        if( prop->m_important ) source = InlineImportant;
+	if( prop->nonCSSHint ) source = NonCSSHint;
+
+	bool first;
+        // give special priority to font-xxx, color properties
+        switch(prop->m_id)
+        {
+        case CSS_PROP_FONT_STYLE:
+	case CSS_PROP_FONT_SIZE:
+	case CSS_PROP_FONT_WEIGHT:
+        case CSS_PROP_FONT_FAMILY:
+        case CSS_PROP_FONT_VARIANT:
+        case CSS_PROP_FONT:
+        case CSS_PROP_COLOR:
+        case CSS_PROP_DIRECTION:
+        case CSS_PROP_DISPLAY:
+            // these have to be applied first, because other properties use the computed
+            // values of these properties.
+	    first = true;
+            break;
+        default:
+            first = false;
+            break;
+        }
+
+	array->prop = prop;
+	array->pseudoId = RenderStyle::NOPSEUDO;
+	array->selector = 0;
+	array->position = i;
+	array->priority = (!first << 30) | (source << 24);
+	propsToApply[numProps++] = array++;
+    }
+    return numProps;
+}
+
+// modified version of the one in kurl.cpp
+static void cleanpath(TQString &path)
+{
+    int pos;
+    while ( (pos = path.find( "/../" )) != -1 ) {
+        int prev = 0;
+        if ( pos > 0 )
+            prev = path.findRev( "/", pos -1 );
+        // don't remove the host, i.e. http://foo.org/../foo.html
+        if (prev < 0 || (prev > 3 && path.findRev("://", prev-1) == prev-2))
+            path.remove( pos, 3);
+        else
+            // matching directory found ?
+            path.remove( prev, pos- prev + 3 );
+    }
+    pos = 0;
+
+    // Don't remove "//" from an anchor identifier. -rjw
+    // Set refPos to -2 to mean "I haven't looked for the anchor yet".
+    // We don't want to waste a function call on the search for the anchor
+    // in the vast majority of cases where there is no "//" in the path.
+    int refPos = -2;
+    while ( (pos = path.find( "//", pos )) != -1) {
+        if (refPos == -2)
+            refPos = path.find("#", 0);
+        if (refPos > 0 && pos >= refPos)
+            break;
+
+        if ( pos == 0 || path[pos-1] != ':' )
+            path.remove( pos, 1 );
+        else
+            pos += 2;
+    }
+    while ( (pos = path.find( "/./" )) != -1)
+        path.remove( pos, 2 );
+    //kdDebug() << "checkPseudoState " << path << endl;
+}
+
+static PseudoState checkPseudoState( const CSSStyleSelector::Encodedurl& encodedurl, DOM::ElementImpl *e )
+{
+    if( e->id() != ID_A ) {
+        return PseudoNone;
+    }
+    DOMString attr = e->getAttribute(ATTR_HREF);
+    if( attr.isNull() ) {
+        return PseudoNone;
+    }
+    TQConstString cu(attr.unicode(), attr.length());
+    TQString u = cu.string();
+    if ( !u.contains("://") ) {
+        if ( u[0] == '/' )
+            u = encodedurl.host + u;
+        else if ( u[0] == '#' )
+            u = encodedurl.file + u;
+        else
+            u = encodedurl.path + u;
+        cleanpath( u );
+    }
+    //completeURL( attr.string() );
+    bool contains = KHTMLFactory::vLinks()->contains( u );
+    if ( !contains && u.contains('/')==2 )
+      contains = KHTMLFactory::vLinks()->contains( u+'/' );
+    return contains ? PseudoVisited : PseudoLink;
+}
+
+// a helper function for parsing nth-arguments
+static bool matchNth(int count, const TQString& nth)
+{
+    if (nth.isEmpty()) return false;
+    int a = 0;
+    int b = 0;
+    if (nth == "odd") {
+        a = 2;
+        b = 1;
+    }
+    else if (nth == "even") {
+        a = 2;
+        b = 0;
+    }
+    else {
+        int n = nth.find('n');
+        if (n != -1) {
+            if (nth[0] == '-')
+                if (n==1)
+                    a = -1;
+                else
+                    a = nth.mid(1,n-1).toInt();
+            else
+                if (n==0)
+                    a = 1;
+                else
+                    a = nth.left(n).toInt();
+
+            int p = nth.find('+');
+            if (p != -1)
+                b = nth.mid(p+1).toInt();
+            else {
+                p = nth.find('-');
+                b = -nth.mid(p+1).toInt();
+            }
+        }
+        else {
+            b = nth.toInt();
+        }
+    }
+    if (a == 0)
+        return count == b;
+    else if (a > 0)
+        if (count < b)
+            return false;
+        else
+            return (count - b) % a == 0;
+    else if (a < 0) {
+        if (count > b)
+            return false;
+        else
+            return (b - count) % (-a) == 0;
+    }
+    return false;
+}
+
+
+// Recursively work the combinator to compute static attribute dependency, similar to
+//structure of checkSubSelectors
+static void precomputeAttributeDependenciesAux(DOM::DocumentImpl* doc, DOM::CSSSelector* sel, bool isAncestor, bool isSubject)
+{
+    if(sel->attr)
+    {
+        // Sets up global dependencies of attributes
+        if (isSubject)
+            doc->dynamicDomRestyler().addDependency(sel->attr, PersonalDependency);
+        else if (isAncestor)
+            doc->dynamicDomRestyler().addDependency(sel->attr, AncestorDependency);
+        else
+            doc->dynamicDomRestyler().addDependency(sel->attr, PredecessorDependency);
+    }
+    if(sel->match == CSSSelector::PseudoClass)
+    {
+	switch (sel->pseudoType()) {
+            case CSSSelector::PseudoNot:
+                precomputeAttributeDependenciesAux(doc, sel->simpleSelector, isAncestor, true);
+                break;
+            default:
+                break;
+        }
+    }
+    CSSSelector::Relation relation = sel->relation;
+    sel = sel->tagHistory;
+    if (!sel) return;
+
+    switch(relation)
+    {
+    case CSSSelector::Descendant:
+    case CSSSelector::Child:
+        precomputeAttributeDependenciesAux(doc, sel, true, false);
+        break;
+    case CSSSelector::IndirectAdjacent:
+    case CSSSelector::DirectAdjacent:
+        precomputeAttributeDependenciesAux(doc, sel, false, false);
+        break;
+    case CSSSelector::SubSelector:
+        precomputeAttributeDependenciesAux(doc, sel, isAncestor, isSubject);
+        break;
+    }
+}
+
+void CSSStyleSelector::precomputeAttributeDependencies(DOM::DocumentImpl* doc, DOM::CSSSelector* sel)
+{
+    precomputeAttributeDependenciesAux(doc, sel, false, true);
+}
+
+// Recursive check of selectors and combinators
+// It can return 3 different values:
+// * SelectorMatches - the selector is match for the node e
+// * SelectorFailsLocal - the selector fails for the node e
+// * SelectorFails - the selector fails for e and any sibling or ancestor of e
+CSSStyleSelector::SelectorMatch CSSStyleSelector::checkSelector(DOM::CSSSelector *sel, DOM::ElementImpl *e, bool isAncestor, bool isSubSelector)
+{
+    // The simple selector has to match
+    if(!checkSimpleSelector(sel, e, isAncestor, isSubSelector)) return SelectorFailsLocal;
+
+    // The rest of the selectors has to match
+    CSSSelector::Relation relation = sel->relation;
+
+    // Prepare next sel
+    sel = sel->tagHistory;
+    if (!sel) return SelectorMatches;
+
+    switch(relation) {
+        case CSSSelector::Descendant:
+        {
+            while(true)
+            {
+                DOM::NodeImpl* n = e->parentNode();
+                if(!n || !n->isElementNode()) return SelectorFails;
+                e = static_cast<ElementImpl *>(n);
+                SelectorMatch match = checkSelector(sel, e, true);
+                if (match != SelectorFailsLocal)
+                    return match;
+            }
+            break;
+        }
+        case CSSSelector::Child:
+        {
+            DOM::NodeImpl* n = e->parentNode();
+            if (!strictParsing)
+                while (n && n->implicitNode()) n = n->parentNode();
+            if(!n || !n->isElementNode()) return SelectorFails;
+            e = static_cast<ElementImpl *>(n);
+            return checkSelector(sel, e, true);
+        }
+        case CSSSelector::IndirectAdjacent:
+        {
+            // Sibling selectors always generate structural dependencies
+            // because newly inserted element might fullfill them.
+            if (e->parentNode()->isElementNode())
+                addDependency(StructuralDependency, static_cast<ElementImpl*>(e->parentNode()));
+            while(true)
+            {
+                DOM::NodeImpl* n = e->previousSibling();
+                while( n && !n->isElementNode() )
+                    n = n->previousSibling();
+                if( !n ) return SelectorFailsLocal;
+                e = static_cast<ElementImpl *>(n);
+                SelectorMatch match = checkSelector(sel, e, false);
+                if (match != SelectorFailsLocal)
+                    return match;
+            };
+            break;
+        }
+        case CSSSelector::DirectAdjacent:
+        {
+            if (e->parentNode()->isElementNode())
+                addDependency(StructuralDependency, static_cast<ElementImpl*>(e->parentNode()));
+            DOM::NodeImpl* n = e->previousSibling();
+            while( n && !n->isElementNode() )
+                n = n->previousSibling();
+            if( !n ) return SelectorFailsLocal;
+            e = static_cast<ElementImpl *>(n);
+            return checkSelector(sel, e, false);
+        }
+        case CSSSelector::SubSelector:
+            return checkSelector(sel, e, isAncestor, true);
+    }
+    assert(false); // never reached
+    return SelectorFails;
+}
+
+void CSSStyleSelector::checkSelector(int selIndex, DOM::ElementImpl * e)
+{
+    assert(e == element); // yes, actually
+
+    dynamicPseudo = RenderStyle::NOPSEUDO;
+
+    selectorCache[ selIndex ].state = Invalid;
+    CSSSelector *sel = selectors[ selIndex ];
+
+    // Check the selector
+     SelectorMatch match = checkSelector(sel, e, true);
+     if(match != SelectorMatches) return;
+
+    if ( dynamicPseudo != RenderStyle::NOPSEUDO ) {
+	selectorCache[selIndex].state = AppliesPseudo;
+	selectors[ selIndex ]->pseudoId = dynamicPseudo;
+    } else
+	selectorCache[ selIndex ].state = Applies;
+    //tqDebug( "selector %d applies", selIndex );
+    //selectors[ selIndex ]->print();
+    return;
+}
+
+void CSSStyleSelector::addDependency(StructuralDependencyType dependencyType, ElementImpl* dependency)
+{
+    element->getDocument()->dynamicDomRestyler().addDependency(element, dependency, dependencyType);
+}
+
+bool CSSStyleSelector::checkSimpleSelector(DOM::CSSSelector *sel, DOM::ElementImpl *e, bool isAncestor, bool isSubSelector)
+{
+    if(!e)
+        return false;
+
+    if (sel->tag != anyQName) {
+        int eltID = e->id();
+        TQ_UINT16 localName = localNamePart(eltID);
+        TQ_UINT16 ns = namespacePart(eltID);
+        TQ_UINT16 selLocalName = localNamePart(sel->tag);
+        TQ_UINT16 selNS = namespacePart(sel->tag);
+
+        if (localName <= ID_LAST_TAG && ns == defaultNamespace) {
+            assert(e->isHTMLElement());
+            ns = xhtmlNamespace;
+        }
+
+        // match on local
+        if (selLocalName != anyLocalName && localName != selLocalName) return false;
+        // match on namespace
+        if (selNS != anyNamespace && ns != selNS) return false;
+    }
+
+    if(sel->attr)
+    {
+        DOMStringImpl* value = e->getAttributeImpl(sel->attr);
+        if(!value) return false; // attribute is not set
+
+        // attributes are always case-sensitive in XHTML
+        // attributes are sometimes case-sensitive in HTML
+        // we only treat id and class selectors as case-sensitive in HTML strict
+        // for compatibility reasons
+        bool caseSensitive = e->getDocument()->htmlMode() == DocumentImpl::XHtml;
+        bool caseSensitive_alt = strictParsing || caseSensitive;
+        caseSensitive |= (sel->attr > ATTR_LAST_CI_ATTR);
+
+        switch(sel->match)
+        {
+        case CSSSelector::Set:
+            // True if we make it this far
+            break;
+        case CSSSelector::Id:
+            caseSensitive = caseSensitive_alt;
+            // no break
+        case CSSSelector::Exact:
+            return (caseSensitive && !strcmp(sel->value, value)) ||
+                   (!caseSensitive && !strcasecmp(sel->value, value));
+            break;
+        case CSSSelector::Class:
+            caseSensitive = caseSensitive_alt;
+            // no break
+        case CSSSelector::List:
+        {
+            int sel_len = sel->value.length();
+            int val_len = value->length();
+            // Be smart compare on length first
+            if (sel_len > val_len) return false;
+            // Selector string may not contain spaces
+            if ((sel->attr != ATTR_CLASS || e->hasClassList()) && sel->value.find(' ') != -1) return false;
+            if (sel_len == val_len)
+                return (caseSensitive && !strcmp(sel->value, value)) ||
+		       (!caseSensitive && !strcasecmp(sel->value, value));
+            // else the value is longer and can be a list
+            if ( sel->match == CSSSelector::Class && !e->hasClassList() ) return false;
+
+            TQChar* sel_uc = sel->value.unicode();
+            TQChar* val_uc = value->unicode();
+
+            TQConstString sel_str(sel_uc, sel_len);
+            TQConstString val_str(val_uc, val_len);
+
+            int pos = 0;
+            for ( ;; ) {
+                pos = val_str.string().find(sel_str.string(), pos, caseSensitive);
+                if ( pos == -1 ) return false;
+                if ( pos == 0 || val_uc[pos-1].isSpace() ) {
+                    int endpos = pos + sel_len;
+                    if ( endpos >= val_len || val_uc[endpos].isSpace() )
+                        break; // We have a match.
+                }
+                ++pos;
+            }
+            break;
+        }
+        case CSSSelector::Contain:
+        {
+            //kdDebug( 6080 ) << "checking for contains match" << endl;
+            TQConstString val_str(value->unicode(), value->length());
+            TQConstString sel_str(sel->value.unicode(), sel->value.length());
+            return val_str.string().contains(sel_str.string(), caseSensitive);
+        }
+        case CSSSelector::Begin:
+        {
+            //kdDebug( 6080 ) << "checking for beginswith match" << endl;
+            TQConstString val_str(value->unicode(), value->length());
+            TQConstString sel_str(sel->value.unicode(), sel->value.length());
+            return val_str.string().startsWith(sel_str.string(), caseSensitive);
+        }
+        case CSSSelector::End:
+        {
+            //kdDebug( 6080 ) << "checking for endswith match" << endl;
+            TQConstString val_str(value->unicode(), value->length());
+            TQConstString sel_str(sel->value.unicode(), sel->value.length());
+            return val_str.string().endsWith(sel_str.string(), caseSensitive);
+        }
+        case CSSSelector::Hyphen:
+        {
+            //kdDebug( 6080 ) << "checking for hyphen match" << endl;
+            TQConstString val_str(value->unicode(), value->length());
+            TQConstString sel_str(sel->value.unicode(), sel->value.length());
+            const TQString& str = val_str.string();
+            const TQString& selStr = sel_str.string();
+            if(str.length() < selStr.length()) return false;
+            // Check if str begins with selStr:
+            if(str.find(selStr, 0, caseSensitive) != 0) return false;
+            // It does. Check for exact match or following '-':
+            if(str.length() != selStr.length()
+                && str[selStr.length()] != '-') return false;
+            break;
+        }
+        case CSSSelector::PseudoClass:
+        case CSSSelector::PseudoElement:
+        case CSSSelector::None:
+            break;
+        }
+    }
+
+    if(sel->match == CSSSelector::PseudoClass || sel->match == CSSSelector::PseudoElement)
+    {
+	switch (sel->pseudoType()) {
+        // Pseudo classes:
+	case CSSSelector::PseudoEmpty:
+	    addDependency(BackwardsStructuralDependency, e);
+            // If e is not closed yet we don't know the number of children
+            if (!e->closed()) {
+                return false;
+            }
+            if (!e->firstChild())
+                return true;
+            else {
+                // check for empty text nodes
+                NodeImpl *t = e->firstChild();
+
+                while (t && t->isTextNode() && static_cast<TextImpl*>(t)->length() == 0) t = t->nextSibling();
+
+                if (t == 0)
+                    return true;
+                else
+                    return false;
+            }
+            break;
+	case CSSSelector::PseudoFirstChild: {
+	    // first-child matches the first child that is an element!
+            if (e->parentNode() && e->parentNode()->isElementNode()) {
+                // Handle dynamic DOM changes
+                addDependency(StructuralDependency, static_cast<ElementImpl*>(e->parentNode()));
+                DOM::NodeImpl* n = e->previousSibling();
+                while ( n && !n->isElementNode() )
+                    n = n->previousSibling();
+                if ( !n )
+                    return true;
+            }
+            break;
+        }
+        case CSSSelector::PseudoLastChild: {
+            // last-child matches the last child that is an element!
+            if (e->parentNode() && e->parentNode()->isElementNode()) {
+                // Handle unfinished parsing and dynamic DOM changes
+                addDependency(BackwardsStructuralDependency, static_cast<ElementImpl*>(e->parentNode()));
+                if (!e->parentNode()->closed()) {
+//                     kdDebug(6080) << e->nodeName().string() << "::last-child: Parent unclosed" << endl;
+                    return false;
+                }
+                DOM::NodeImpl* n = e->nextSibling();
+                while ( n && !n->isElementNode() )
+                    n = n->nextSibling();
+                if ( !n )
+                    return true;
+            }
+            break;
+        }
+        case CSSSelector::PseudoOnlyChild: {
+            // If both first-child and last-child apply, then only-child applies.
+            if (e->parentNode() && e->parentNode()->isElementNode()) {
+                addDependency(BackwardsStructuralDependency, static_cast<ElementImpl*>(e->parentNode()));
+                if (!e->parentNode()->closed()) {
+                    return false;
+                }
+                DOM::NodeImpl* n = e->previousSibling();
+                while ( n && !n->isElementNode() )
+                    n = n->previousSibling();
+                if ( !n ) {
+                    n = e->nextSibling();
+                    while ( n && !n->isElementNode() )
+                        n = n->nextSibling();
+                    if ( !n )
+                        return true;
+                }
+            }
+            break;
+        }
+        case CSSSelector::PseudoNthChild: {
+	    // nth-child matches every (a*n+b)th element!
+            if (e->parentNode() && e->parentNode()->isElementNode()) {
+                addDependency(StructuralDependency, static_cast<ElementImpl*>(e->parentNode()));
+                int count = 1;
+                DOM::NodeImpl* n = e->previousSibling();
+                while ( n ) {
+                    if (n->isElementNode()) count++;
+                    n = n->previousSibling();
+                }
+//                 kdDebug(6080) << "NthChild " << count << "=" << sel->string_arg << endl;
+                if (matchNth(count,sel->string_arg.string()))
+                    return true;
+            }
+            break;
+        }
+        case CSSSelector::PseudoNthLastChild: {
+            if (e->parentNode() && e->parentNode()->isElementNode()) {
+                addDependency(BackwardsStructuralDependency, static_cast<ElementImpl*>(e->parentNode()));
+                if (!e->parentNode()->closed()) {
+                    return false;
+                }
+                int count = 1;
+                DOM::NodeImpl* n = e->nextSibling();
+                while ( n ) {
+                    if (n->isElementNode()) count++;
+                    n = n->nextSibling();
+                }
+//                kdDebug(6080) << "NthLastChild " << count << "=" << sel->string_arg << endl;
+                if (matchNth(count,sel->string_arg.string()))
+                    return true;
+            }
+            break;
+        }
+	case CSSSelector::PseudoFirstOfType: {
+	    // first-of-type matches the first element of its type!
+            if (e->parentNode() && e->parentNode()->isElementNode()) {
+                addDependency(StructuralDependency, static_cast<ElementImpl*>(e->parentNode()));
+                const DOMString& type = e->tagName();
+                DOM::NodeImpl* n = e->previousSibling();
+                while ( n ) {
+                    if (n->isElementNode())
+                        if (static_cast<ElementImpl*>(n)->tagName() == type) break;
+                    n = n->previousSibling();
+                }
+                if ( !n )
+                    return true;
+            }
+            break;
+        }
+        case CSSSelector::PseudoLastOfType: {
+            // last-child matches the last child that is an element!
+            if (e->parentNode() && e->parentNode()->isElementNode()) {
+                addDependency(BackwardsStructuralDependency, static_cast<ElementImpl*>(e->parentNode()));
+                if (!e->parentNode()->closed()) {
+                    return false;
+                }
+                const DOMString& type = e->tagName();
+                DOM::NodeImpl* n = e->nextSibling();
+                while ( n ) {
+                    if (n->isElementNode())
+                        if (static_cast<ElementImpl*>(n)->tagName() == type) break;
+                    n = n->nextSibling();
+                }
+                if ( !n )
+                    return true;
+            }
+            break;
+        }
+        case CSSSelector::PseudoOnlyOfType: {
+            // If both first-of-type and last-of-type apply, then only-of-type applies.
+            if (e->parentNode() && e->parentNode()->isElementNode()) {
+                addDependency(BackwardsStructuralDependency, static_cast<ElementImpl*>(e->parentNode()));
+                if (!e->parentNode()->closed()) {
+                    return false;
+                }
+                const DOMString& type = e->tagName();
+                DOM::NodeImpl* n = e->previousSibling();
+                while ( n && !(n->isElementNode() && static_cast<ElementImpl*>(n)->tagName() == type))
+                    n = n->previousSibling();
+                if ( !n ) {
+                    n = e->nextSibling();
+                    while ( n && !(n->isElementNode() && static_cast<ElementImpl*>(n)->tagName() == type))
+                        n = n->nextSibling();
+                    if ( !n )
+                        return true;
+	        }
+            }
+	    break;
+        }
+        case CSSSelector::PseudoNthOfType: {
+	    // nth-of-type matches every (a*n+b)th element of this type!
+            if (e->parentNode() && e->parentNode()->isElementNode()) {
+                addDependency(StructuralDependency, static_cast<ElementImpl*>(e->parentNode()));
+                int count = 1;
+                const DOMString& type = e->tagName();
+                DOM::NodeImpl* n = e->previousSibling();
+                while ( n ) {
+                    if (n->isElementNode() && static_cast<ElementImpl*>(n)->tagName() == type) count++;
+                    n = n->previousSibling();
+                }
+//                kdDebug(6080) << "NthOfType " << count << "=" << sel->string_arg << endl;
+                if (matchNth(count,sel->string_arg.string()))
+                    return true;
+            }
+            break;
+        }
+        case CSSSelector::PseudoNthLastOfType: {
+            if (e->parentNode() && e->parentNode()->isElementNode()) {
+                addDependency(BackwardsStructuralDependency, static_cast<ElementImpl*>(e->parentNode()));
+                if (!e->parentNode()->closed()) {
+                    return false;
+                }
+                int count = 1;
+                const DOMString& type = e->tagName();
+                DOM::NodeImpl* n = e->nextSibling();
+                while ( n ) {
+                    if (n->isElementNode() && static_cast<ElementImpl*>(n)->tagName() == type) count++;
+                    n = n->nextSibling();
+                }
+//                kdDebug(6080) << "NthLastOfType " << count << "=" << sel->string_arg << endl;
+                if (matchNth(count,sel->string_arg.string()))
+                    return true;
+            }
+            break;
+        }
+        case CSSSelector::PseudoTarget:
+            if (e == e->getDocument()->getCSSTarget())
+                return true;
+            break;
+        case CSSSelector::PseudoRoot:
+            if (e == e->getDocument()->documentElement())
+                return true;
+            break;
+	case CSSSelector::PseudoLink:
+	    if (e == element) {
+	       // cache pseudoState
+	       if ( pseudoState == PseudoUnknown )
+                    pseudoState = checkPseudoState( encodedurl, e );
+               if ( pseudoState == PseudoLink )
+                    return true;
+            } else
+                return checkPseudoState( encodedurl, e ) == PseudoLink;
+	    break;
+	case CSSSelector::PseudoVisited:
+	    if (e == element) {
+                // cache pseudoState
+                if ( pseudoState == PseudoUnknown )
+                    pseudoState = checkPseudoState( encodedurl, e );
+                if ( pseudoState == PseudoVisited )
+                    return true;
+            } else
+                return checkPseudoState( encodedurl, e ) == PseudoVisited;
+	    break;
+        case CSSSelector::PseudoHover: {
+	    // If we're in quirks mode, then *:hover should only match focusable elements.
+	    if (strictParsing || (sel->tag != anyQName) || isSubSelector || e->isFocusable() ) {
+                addDependency(HoverDependency, e);
+
+                if (e->hovered())
+                    return true;
+            }
+            break;
+        }
+	case CSSSelector::PseudoActive:
+	    // If we're in quirks mode, then *:active should only match focusable elements
+	    if (strictParsing || (sel->tag != anyQName) || isSubSelector || e->isFocusable()) {
+                addDependency(ActiveDependency, e);
+
+		if (e->active())
+		    return true;
+	    }
+	    break;
+	case CSSSelector::PseudoFocus:
+	    if (e != element && e->isFocusable()) {
+                // *:focus is a default style, no need to track it.
+                addDependency(OtherStateDependency, e);
+            }
+            if (e->focused()) return true;
+            break;
+        case CSSSelector::PseudoLang: {
+            // Set dynamic attribute dependency
+            if (e == element) {
+                e->getDocument()->dynamicDomRestyler().addDependency(ATTR_LANG, PersonalDependency);
+                e->getDocument()->dynamicDomRestyler().addDependency(ATTR_LANG, AncestorDependency);
+            }
+            else if (isAncestor)
+                e->getDocument()->dynamicDomRestyler().addDependency(ATTR_LANG, AncestorDependency);
+            else
+                e->getDocument()->dynamicDomRestyler().addDependency(ATTR_LANG, PredecessorDependency);
+            // ### check xml:lang attribute in XML and XHTML documents
+            DOMString value = e->getAttribute(ATTR_LANG);
+            // The LANG attribute is inherited like a property
+            NodeImpl *n = e->parent();;
+            while (n && value.isEmpty()) {
+                if (n->isElementNode()) {
+                    value = static_cast<ElementImpl*>(n)->getAttribute(ATTR_LANG);
+                } else
+                if (n->isDocumentNode()) {
+                    value = static_cast<DocumentImpl*>(n)->contentLanguage();
+                }
+                n = n->parent();
+            }
+            if (value.isEmpty()) return false;
+
+            TQString langAttr = value.string();
+            TQString langSel = sel->string_arg.string();
+
+            if(langAttr.length() < langSel.length()) return false;
+
+            langAttr = langAttr.lower();
+            langSel = langSel.lower();
+//             kdDebug(6080) << ":lang " << langAttr << "=" << langSel << "?" << endl;
+            return (langAttr == langSel || langAttr.startsWith(langSel+"-"));
+        }
+        case CSSSelector::PseudoNot: {
+            // check the simple selector
+            for (CSSSelector* subSel = sel->simpleSelector; subSel;
+                 subSel = subSel->tagHistory) {
+                // :not cannot nest.  I don't really know why this is a restriction in CSS3,
+                // but it is, so let's honor it.
+                if (subSel->simpleSelector)
+                    break;
+                if (!checkSimpleSelector(subSel, e, isAncestor, true))
+                    return true;
+            }
+            break;
+        }
+        case CSSSelector::PseudoEnabled: {
+            if (e->isGenericFormElement()) {
+                addDependency(OtherStateDependency, e);
+                HTMLGenericFormElementImpl *form;
+                form = static_cast<HTMLGenericFormElementImpl*>(e);
+                return !form->disabled();
+            }
+            break;
+        }
+        case CSSSelector::PseudoDisabled: {
+            if (e->isGenericFormElement()) {
+                addDependency(OtherStateDependency, e);
+                HTMLGenericFormElementImpl *form;
+                form = static_cast<HTMLGenericFormElementImpl*>(e);
+                return form->disabled();
+            }
+            break;
+        }
+        case CSSSelector::PseudoContains: {
+            if (e->isHTMLElement()) {
+                addDependency(BackwardsStructuralDependency, e);
+                if (!e->closed()) {
+                   return false;
+                }
+                HTMLElementImpl *elem;
+                elem = static_cast<HTMLElementImpl*>(e);
+                DOMString s = elem->innerText();
+                TQString selStr = sel->string_arg.string();
+//                kdDebug(6080) << ":contains(\"" << selStr << "\")" << " on \"" << s << "\"" << endl;
+                return s.string().contains(selStr);
+            }
+            break;
+        }
+	case CSSSelector::PseudoChecked: {
+           if (e->isHTMLElement() && e->id() == ID_INPUT) {
+               addDependency(OtherStateDependency, e);
+               return (static_cast<HTMLInputElementImpl*>(e)->checked());
+           }
+           return false;
+        }
+ 	case CSSSelector::PseudoIndeterminate: {
+#if 0
+           if (e->isHTMLElement() && e->id() == ID_INPUT) {
+               return (static_cast<HTMLInputElementImpl*>(e)->indeterminate() &&
+                      !static_cast<HTMLInputElementImpl*>(e)->checked());
+           }
+           return false;
+#endif
+        }
+	case CSSSelector::PseudoOther:
+	    break;
+
+	// Pseudo-elements:
+	case CSSSelector::PseudoFirstLine:
+	case CSSSelector::PseudoFirstLetter:
+	case CSSSelector::PseudoSelection:
+	case CSSSelector::PseudoBefore:
+	case CSSSelector::PseudoAfter:
+	case CSSSelector::PseudoMarker:
+	case CSSSelector::PseudoReplaced:
+	    // Pseudo-elements can only apply to subject
+	    if ( e == element ) {
+                // Pseudo-elements has to be the last sub-selector on subject
+                if (sel->tagHistory && sel->relation == CSSSelector::SubSelector) return false;
+
+                assert(dynamicPseudo == RenderStyle::NOPSEUDO);
+
+                switch (sel->pseudoType()) {
+                case CSSSelector::PseudoFirstLine:
+                    dynamicPseudo = RenderStyle::FIRST_LINE;
+                    break;
+                case CSSSelector::PseudoFirstLetter:
+                    dynamicPseudo = RenderStyle::FIRST_LETTER;
+                    break;
+                case CSSSelector::PseudoSelection:
+                    dynamicPseudo = RenderStyle::SELECTION;
+                    break;
+                case CSSSelector::PseudoBefore:
+                    dynamicPseudo = RenderStyle::BEFORE;
+                    break;
+                case CSSSelector::PseudoAfter:
+                    dynamicPseudo = RenderStyle::AFTER;
+                    break;
+                case CSSSelector::PseudoMarker:
+                    dynamicPseudo = RenderStyle::MARKER;
+                    break;
+                case CSSSelector::PseudoReplaced:
+                    dynamicPseudo = RenderStyle::REPLACED;
+                    break;
+                default:
+                    assert(false);
+                }
+		return true;
+	    }
+	    break;
+	case CSSSelector::PseudoNotParsed:
+	    assert(false);
+	    break;
+	}
+	return false;
+    }
+    // ### add the rest of the checks...
+    return true;
+}
+
+void CSSStyleSelector::clearLists()
+{
+    delete [] selectors;
+    if ( selectorCache ) {
+        for ( unsigned int i = 0; i < selectors_size; i++ )
+            delete [] selectorCache[i].props;
+
+        delete [] selectorCache;
+    }
+    if ( properties ) {
+	CSSOrderedProperty **prop = properties;
+	while ( *prop ) {
+	    delete (*prop);
+	    prop++;
+	}
+        delete [] properties;
+    }
+    selectors = 0;
+    properties = 0;
+    selectorCache = 0;
+}
+
+
+void CSSStyleSelector::buildLists()
+{
+    clearLists();
+    // collect all selectors and Properties in lists. Then transfer them to the array for faster lookup.
+
+    TQPtrList<CSSSelector> selectorList;
+    CSSOrderedPropertyList propertyList;
+
+    if(m_medium == "print" && defaultPrintStyle)
+      defaultPrintStyle->collect( &selectorList, &propertyList, Default,
+        Default );
+    else if(defaultStyle) defaultStyle->collect( &selectorList, &propertyList,
+      Default, Default );
+
+    if (!strictParsing && defaultQuirksStyle)
+        defaultQuirksStyle->collect( &selectorList, &propertyList, Default, Default );
+
+    if(userStyle) userStyle->collect(&selectorList, &propertyList, User, UserImportant );
+    if(authorStyle) authorStyle->collect(&selectorList, &propertyList, Author, AuthorImportant );
+
+    selectors_size = selectorList.count();
+    selectors = new CSSSelector *[selectors_size];
+    CSSSelector *s = selectorList.first();
+    CSSSelector **sel = selectors;
+    while ( s ) {
+	*sel = s;
+	s = selectorList.next();
+	++sel;
+    }
+
+    selectorCache = new SelectorCache[selectors_size];
+    for ( unsigned int i = 0; i < selectors_size; i++ ) {
+        selectorCache[i].state = Unknown;
+        selectorCache[i].props_size = 0;
+        selectorCache[i].props = 0;
+    }
+
+    // presort properties. Should make the sort() calls in styleForElement faster.
+    propertyList.sort();
+    properties_size = propertyList.count() + 1;
+    properties = new CSSOrderedProperty *[ properties_size ];
+    CSSOrderedProperty *p = propertyList.first();
+    CSSOrderedProperty **prop = properties;
+    while ( p ) {
+	*prop = p;
+	p = propertyList.next();
+	++prop;
+    }
+    *prop = 0;
+
+    unsigned int* offsets = new unsigned int[selectors_size];
+    if(properties[0])
+	offsets[properties[0]->selector] = 0;
+    for(unsigned int p = 1; p < properties_size; ++p) {
+
+	if(!properties[p] || (properties[p]->selector != properties[p - 1]->selector)) {
+	    unsigned int sel = properties[p - 1]->selector;
+            int* newprops = new int[selectorCache[sel].props_size+2];
+            for ( unsigned int i=0; i < selectorCache[sel].props_size; i++ )
+                newprops[i] = selectorCache[sel].props[i];
+
+	    newprops[selectorCache[sel].props_size] = offsets[sel];
+	    newprops[selectorCache[sel].props_size+1] = p - offsets[sel];
+            delete [] selectorCache[sel].props;
+            selectorCache[sel].props = newprops;
+            selectorCache[sel].props_size += 2;
+
+	    if(properties[p]) {
+		sel = properties[p]->selector;
+		offsets[sel] = p;
+            }
+        }
+    }
+    delete [] offsets;
+}
+
+
+// ----------------------------------------------------------------------
+
+
+CSSOrderedRule::CSSOrderedRule(DOM::CSSStyleRuleImpl *r, DOM::CSSSelector *s, int _index)
+{
+    rule = r;
+    if(rule) r->ref();
+    index = _index;
+    selector = s;
+}
+
+CSSOrderedRule::~CSSOrderedRule()
+{
+    if(rule) rule->deref();
+}
+
+// -----------------------------------------------------------------
+
+CSSStyleSelectorList::CSSStyleSelectorList()
+    : TQPtrList<CSSOrderedRule>()
+{
+    setAutoDelete(true);
+}
+CSSStyleSelectorList::~CSSStyleSelectorList()
+{
+}
+
+void CSSStyleSelectorList::append( CSSStyleSheetImpl *sheet,
+                                   const DOMString &medium )
+{
+    if(!sheet || !sheet->isCSSStyleSheet()) return;
+
+    // No media implies "all", but if a medialist exists it must
+    // contain our current medium
+    if( sheet->media() && !sheet->media()->contains( medium ) )
+        return; // style sheet not applicable for this medium
+
+    int len = sheet->length();
+
+    for(int i = 0; i< len; i++)
+    {
+        StyleBaseImpl *item = sheet->item(i);
+        if(item->isStyleRule())
+        {
+            CSSStyleRuleImpl *r = static_cast<CSSStyleRuleImpl *>(item);
+            TQPtrList<CSSSelector> *s = r->selector();
+            for(int j = 0; j < (int)s->count(); j++)
+            {
+                CSSOrderedRule *rule = new CSSOrderedRule(r, s->at(j), count());
+		TQPtrList<CSSOrderedRule>::append(rule);
+                //kdDebug( 6080 ) << "appending StyleRule!" << endl;
+            }
+        }
+        else if(item->isImportRule())
+        {
+            CSSImportRuleImpl *import = static_cast<CSSImportRuleImpl *>(item);
+
+            //kdDebug( 6080 ) << "@import: Media: "
+            //                << import->media()->mediaText().string() << endl;
+
+            if( !import->media() || import->media()->contains( medium ) )
+            {
+                CSSStyleSheetImpl *importedSheet = import->styleSheet();
+                append( importedSheet, medium );
+            }
+        }
+        else if( item->isMediaRule() )
+        {
+            CSSMediaRuleImpl *r = static_cast<CSSMediaRuleImpl *>( item );
+            CSSRuleListImpl *rules = r->cssRules();
+
+            //DOMString mediaText = media->mediaText();
+            //kdDebug( 6080 ) << "@media: Media: "
+            //                << r->media()->mediaText().string() << endl;
+
+            if( ( !r->media() || r->media()->contains( medium ) ) && rules)
+            {
+                // Traverse child elements of the @import rule. Since
+                // many elements are not allowed as child we do not use
+                // a recursive call to append() here
+                for( unsigned j = 0; j < rules->length(); j++ )
+                {
+                    //kdDebug( 6080 ) << "*** Rule #" << j << endl;
+
+                    CSSRuleImpl *childItem = rules->item( j );
+                    if( childItem->isStyleRule() )
+                    {
+                        // It is a StyleRule, so append it to our list
+                        CSSStyleRuleImpl *styleRule =
+                                static_cast<CSSStyleRuleImpl *>( childItem );
+
+                        TQPtrList<CSSSelector> *s = styleRule->selector();
+                        for( int j = 0; j < ( int ) s->count(); j++ )
+                        {
+                            CSSOrderedRule *orderedRule = new CSSOrderedRule(
+                                            styleRule, s->at( j ), count() );
+                	    TQPtrList<CSSOrderedRule>::append( orderedRule );
+                        }
+                    }
+                    else
+                    {
+                        //kdDebug( 6080 ) << "Ignoring child rule of "
+                        //    "ImportRule: rule is not a StyleRule!" << endl;
+                    }
+                }   // for rules
+            }   // if rules
+            else
+            {
+                //kdDebug( 6080 ) << "CSSMediaRule not rendered: "
+                //                << "rule empty or wrong medium!" << endl;
+            }
+        }
+        // ### include other rules
+    }
+}
+
+
+void CSSStyleSelectorList::collect( TQPtrList<CSSSelector> *selectorList, CSSOrderedPropertyList *propList,
+				    Source regular, Source important )
+{
+    CSSOrderedRule *r = first();
+    while( r ) {
+	CSSSelector *sel = selectorList->first();
+	int selectorNum = 0;
+	while( sel ) {
+	    if ( *sel == *(r->selector) )
+		break;
+	    sel = selectorList->next();
+	    selectorNum++;
+	}
+	if ( !sel )
+	    selectorList->append( r->selector );
+//	else
+//	    tqDebug("merged one selector");
+	propList->append(r->rule->declaration(), selectorNum, r->selector->specificity(), regular, important );
+	r = next();
+    }
+}
+
+// -------------------------------------------------------------------------
+
+int CSSOrderedPropertyList::compareItems(TQPtrCollection::Item i1, TQPtrCollection::Item i2)
+{
+    int diff =  static_cast<CSSOrderedProperty *>(i1)->priority
+        - static_cast<CSSOrderedProperty *>(i2)->priority;
+    return diff ? diff : static_cast<CSSOrderedProperty *>(i1)->position
+        - static_cast<CSSOrderedProperty *>(i2)->position;
+}
+
+void CSSOrderedPropertyList::append(DOM::CSSStyleDeclarationImpl *decl, uint selector, uint specificity,
+				    Source regular, Source important )
+{
+    TQPtrList<CSSProperty> *values = decl->values();
+    if(!values) return;
+    int len = values->count();
+    for(int i = 0; i < len; i++)
+    {
+        CSSProperty *prop = values->at(i);
+	Source source = regular;
+
+	if( prop->m_important ) source = important;
+	if( prop->nonCSSHint ) source = NonCSSHint;
+
+	bool first = false;
+        // give special priority to font-xxx, color properties
+        switch(prop->m_id)
+        {
+        case CSS_PROP_FONT_STYLE:
+	case CSS_PROP_FONT_SIZE:
+	case CSS_PROP_FONT_WEIGHT:
+        case CSS_PROP_FONT_FAMILY:
+        case CSS_PROP_FONT_VARIANT:
+        case CSS_PROP_FONT:
+        case CSS_PROP_COLOR:
+        case CSS_PROP_DIRECTION:
+        case CSS_PROP_DISPLAY:
+            // these have to be applied first, because other properties use the computed
+            // values of these porperties.
+	    first = true;
+            break;
+        default:
+            break;
+        }
+
+	TQPtrList<CSSOrderedProperty>::append(new CSSOrderedProperty(prop, selector,
+								 first, source, specificity,
+								 count() ));
+    }
+}
+
+// -------------------------------------------------------------------------------------
+// this is mostly boring stuff on how to apply a certain rule to the renderstyle...
+
+static Length convertToLength( CSSPrimitiveValueImpl *primitiveValue, RenderStyle *style, TQPaintDeviceMetrics *paintDeviceMetrics, bool *ok = 0 )
+{
+    Length l;
+    if ( !primitiveValue ) {
+	if ( ok )
+            *ok = false;
+    } else {
+	int type = primitiveValue->primitiveType();
+	if(type > CSSPrimitiveValue::CSS_PERCENTAGE && type < CSSPrimitiveValue::CSS_DEG)
+	    l = Length(primitiveValue->computeLength(style, paintDeviceMetrics), Fixed);
+	else if(type == CSSPrimitiveValue::CSS_PERCENTAGE)
+	    l = Length(int(primitiveValue->floatValue(CSSPrimitiveValue::CSS_PERCENTAGE)), Percent);
+	else if(type == CSSPrimitiveValue::CSS_NUMBER)
+	    l = Length(int(primitiveValue->floatValue(CSSPrimitiveValue::CSS_NUMBER)*100), Percent);
+	else if (type == CSSPrimitiveValue::CSS_HTML_RELATIVE)
+	    l = Length(int(primitiveValue->floatValue(CSSPrimitiveValue::CSS_HTML_RELATIVE)), Relative);
+	else if ( ok )
+	    *ok = false;
+    }
+    return l;
+}
+
+
+// color mapping code
+struct colorMap {
+    int css_value;
+    QRgb color;
+};
+
+static const colorMap cmap[] = {
+    { CSS_VAL_AQUA, 0xFF00FFFF },
+    { CSS_VAL_BLACK, 0xFF000000 },
+    { CSS_VAL_BLUE, 0xFF0000FF },
+    { CSS_VAL_CRIMSON, 0xFFDC143C },
+    { CSS_VAL_FUCHSIA, 0xFFFF00FF },
+    { CSS_VAL_GRAY, 0xFF808080 },
+    { CSS_VAL_GREEN, 0xFF008000  },
+    { CSS_VAL_INDIGO, 0xFF4B0082 },
+    { CSS_VAL_LIME, 0xFF00FF00 },
+    { CSS_VAL_MAROON, 0xFF800000 },
+    { CSS_VAL_NAVY, 0xFF000080 },
+    { CSS_VAL_OLIVE, 0xFF808000  },
+    { CSS_VAL_ORANGE, 0xFFFFA500 },
+    { CSS_VAL_PURPLE, 0xFF800080 },
+    { CSS_VAL_RED, 0xFFFF0000 },
+    { CSS_VAL_SILVER, 0xFFC0C0C0 },
+    { CSS_VAL_TEAL, 0xFF008080  },
+    { CSS_VAL_WHITE, 0xFFFFFFFF },
+    { CSS_VAL_YELLOW, 0xFFFFFF00 },
+    { CSS_VAL_INVERT, invertedColor },
+    { CSS_VAL_TRANSPARENT, transparentColor },
+    { CSS_VAL_GREY, 0xff808080 },
+    { 0, 0 }
+};
+
+struct uiColors {
+    int css_value;
+    const char * configGroup;
+    const char * configEntry;
+TQPalette::ColorGroup group;
+TQColorGroup::ColorRole role;
+};
+
+const char * const wmgroup = "WM";
+const char * const generalgroup = "General";
+
+/* Mapping system settings to CSS 2
+* Tried hard to get an appropriate mapping - schlpbch
+*/
+static const uiColors uimap[] = {
+	// Active window border.
+    { CSS_VAL_ACTIVEBORDER, wmgroup, "background", TQPalette::Active, TQColorGroup::Light },
+	// Active window caption.
+    { CSS_VAL_ACTIVECAPTION, wmgroup, "background", TQPalette::Active, TQColorGroup::Text },
+        // Text in caption, size box, and scrollbar arrow box.
+    { CSS_VAL_CAPTIONTEXT, wmgroup, "activeForeground", TQPalette::Active, TQColorGroup::Text },
+	// Face color for three-dimensional display elements.
+    { CSS_VAL_BUTTONFACE, wmgroup, 0, TQPalette::Inactive, TQColorGroup::Button },
+	// Dark shadow for three-dimensional display elements (for edges facing away from the light source).
+    { CSS_VAL_BUTTONHIGHLIGHT, wmgroup, 0, TQPalette::Inactive, TQColorGroup::Light },
+	// Shadow color for three-dimensional display elements.
+    { CSS_VAL_BUTTONSHADOW, wmgroup, 0, TQPalette::Inactive, TQColorGroup::Shadow },
+	// Text on push buttons.
+    { CSS_VAL_BUTTONTEXT, wmgroup, "buttonForeground", TQPalette::Inactive, TQColorGroup::ButtonText },
+	// Dark shadow for three-dimensional display elements.
+    { CSS_VAL_THREEDDARKSHADOW, wmgroup, 0, TQPalette::Inactive, TQColorGroup::Dark },
+	// Face color for three-dimensional display elements.
+    { CSS_VAL_THREEDFACE, wmgroup, 0, TQPalette::Inactive, TQColorGroup::Button },
+	// Highlight color for three-dimensional display elements.
+    { CSS_VAL_THREEDHIGHLIGHT, wmgroup, 0, TQPalette::Inactive, TQColorGroup::Light },
+	// Light color for three-dimensional display elements (for edges facing the light source).
+    { CSS_VAL_THREEDLIGHTSHADOW, wmgroup, 0, TQPalette::Inactive, TQColorGroup::Midlight },
+	// Dark shadow for three-dimensional display elements.
+    { CSS_VAL_THREEDSHADOW, wmgroup, 0, TQPalette::Inactive, TQColorGroup::Shadow },
+
+    // Inactive window border.
+    { CSS_VAL_INACTIVEBORDER, wmgroup, "background", TQPalette::Disabled, TQColorGroup::Background },
+    // Inactive window caption.
+    { CSS_VAL_INACTIVECAPTION, wmgroup, "inactiveBackground", TQPalette::Disabled, TQColorGroup::Background },
+    // Color of text in an inactive caption.
+    { CSS_VAL_INACTIVECAPTIONTEXT, wmgroup, "inactiveForeground", TQPalette::Disabled, TQColorGroup::Text },
+    { CSS_VAL_GRAYTEXT, wmgroup, 0, TQPalette::Disabled, TQColorGroup::Text },
+
+	// Menu background
+    { CSS_VAL_MENU, generalgroup, "background", TQPalette::Inactive, TQColorGroup::Background },
+	// Text in menus
+    { CSS_VAL_MENUTEXT, generalgroup, "foreground", TQPalette::Inactive, TQColorGroup::Background },
+
+        // Text of item(s) selected in a control.
+    { CSS_VAL_HIGHLIGHT, generalgroup, "selectBackground", TQPalette::Inactive, TQColorGroup::Background },
+
+    // Text of item(s) selected in a control.
+    { CSS_VAL_HIGHLIGHTTEXT, generalgroup, "selectForeground", TQPalette::Inactive, TQColorGroup::Background },
+
+	// Background color of multiple document interface.
+    { CSS_VAL_APPWORKSPACE, generalgroup, "background", TQPalette::Inactive, TQColorGroup::Text },
+
+	// Scroll bar gray area.
+    { CSS_VAL_SCROLLBAR, generalgroup, "background", TQPalette::Inactive, TQColorGroup::Background },
+
+	// Window background.
+    { CSS_VAL_WINDOW, generalgroup, "windowBackground", TQPalette::Inactive, TQColorGroup::Background },
+	// Window frame.
+    { CSS_VAL_WINDOWFRAME, generalgroup, "windowBackground", TQPalette::Inactive, TQColorGroup::Background },
+        // WindowText
+    { CSS_VAL_WINDOWTEXT, generalgroup, "windowForeground", TQPalette::Inactive, TQColorGroup::Text },
+    { CSS_VAL_TEXT, generalgroup, 0, TQPalette::Inactive, TQColorGroup::Text },
+    { 0, 0, 0, TQPalette::NColorGroups, TQColorGroup::NColorRoles }
+};
+
+static TQColor colorForCSSValue( int css_value )
+{
+    // try the regular ones first
+    const colorMap *col = cmap;
+    while ( col->css_value && col->css_value != css_value )
+	++col;
+    if ( col->css_value )
+	return col->color;
+
+    const uiColors *uicol = uimap;
+    while ( uicol->css_value && uicol->css_value != css_value )
+	++uicol;
+#ifndef APPLE_CHANGES
+    if ( !uicol->css_value ) {
+	if ( css_value == CSS_VAL_INFOBACKGROUND )
+	    return TQToolTip::palette().inactive().background();
+	else if ( css_value == CSS_VAL_INFOTEXT )
+	    return TQToolTip::palette().inactive().foreground();
+	else if ( css_value == CSS_VAL_BACKGROUND ) {
+	    TDEConfig bckgrConfig("kdesktoprc", true, false); // No multi-screen support
+	    bckgrConfig.setGroup("Desktop0");
+	    // Desktop background.
+	    return bckgrConfig.readColorEntry("Color1", &tqApp->palette().disabled().background());
+	}
+	return TQColor();
+    }
+#endif
+
+    const TQPalette &pal = tqApp->palette();
+    TQColor c = pal.color( uicol->group, uicol->role );
+#ifndef APPLE_CHANGES
+    if ( uicol->configEntry ) {
+	TDEConfig *globalConfig = TDEGlobal::config();
+	globalConfig->setGroup( uicol->configGroup );
+	c = globalConfig->readColorEntry( uicol->configEntry, &c );
+    }
+#endif
+
+    return c;
+}
+
+static inline int nextFontSize(const TQValueVector<int>& a, int v, bool smaller)
+{
+    // return the nearest bigger/smaller value in scale a, when v is in range.
+    // otherwise increase/decrease value using a 1.2 fixed ratio
+    int m, l = 0, r = a.count()-1;
+    while (l <= r) {
+        m = (l+r)/2;
+        if (a[m] == v)
+            return smaller ? ( m ? a[m-1] : (v*5)/6 ) :
+                             ( m+1<int(a.count()) ? a[m+1] : (v*6)/5 );
+        else if (v < a[m])
+            r = m-1;
+        else
+            l = m+1;
+    }
+    if (!l)
+        return smaller ? (v*5)/6 : kMin((v*6)/5, a[0]);
+    if (l == int(a.count()))
+        return smaller ? kMax((v*5)/6, a[r]) : (v*6)/5;
+
+    return smaller ? a[r] : a[l];
+}
+
+void CSSStyleSelector::applyRule( int id, DOM::CSSValueImpl *value )
+{
+//     kdDebug( 6080 ) << "applying property " << getPropertyName(id) << endl;
+
+    CSSPrimitiveValueImpl *primitiveValue = 0;
+    if(value->isPrimitiveValue()) primitiveValue = static_cast<CSSPrimitiveValueImpl *>(value);
+
+    Length l;
+    bool apply = false;
+
+    bool isInherit = (parentNode && value->cssValueType() == CSSValue::CSS_INHERIT);
+    bool isInitial = (value->cssValueType() == CSSValue::CSS_INITIAL) ||
+                     (!parentNode && value->cssValueType() == CSSValue::CSS_INHERIT);
+
+    // These properties are used to set the correct margins/padding on RTL lists.
+    if (id == CSS_PROP__KHTML_MARGIN_START)
+        id = style->direction() == LTR ? CSS_PROP_MARGIN_LEFT : CSS_PROP_MARGIN_RIGHT;
+    else if (id == CSS_PROP__KHTML_PADDING_START)
+        id = style->direction() == LTR ? CSS_PROP_PADDING_LEFT : CSS_PROP_PADDING_RIGHT;
+
+    // What follows is a list that maps the CSS properties into their corresponding front-end
+    // RenderStyle values.  Shorthands (e.g. border, background) occur in this list as well and
+    // are only hit when mapping "inherit" or "initial" into front-end values.
+    switch(id)
+    {
+// ident only properties
+    case CSS_PROP_BACKGROUND_ATTACHMENT:
+        HANDLE_BACKGROUND_VALUE(backgroundAttachment, BackgroundAttachment, value)
+        break;
+    case CSS_PROP__KHTML_BACKGROUND_CLIP:
+        HANDLE_BACKGROUND_VALUE(backgroundClip, BackgroundClip, value)
+        break;
+    case CSS_PROP__KHTML_BACKGROUND_ORIGIN:
+        HANDLE_BACKGROUND_VALUE(backgroundOrigin, BackgroundOrigin, value)
+        break;
+    case CSS_PROP_BACKGROUND_REPEAT:
+        HANDLE_BACKGROUND_VALUE(backgroundRepeat, BackgroundRepeat, value)
+        break;
+    case CSS_PROP__KHTML_BACKGROUND_SIZE:
+        HANDLE_BACKGROUND_VALUE(backgroundSize, BackgroundSize, value)
+        break;
+    case CSS_PROP_BORDER_COLLAPSE:
+        HANDLE_INHERIT_AND_INITIAL(borderCollapse, BorderCollapse)
+        if(!primitiveValue) break;
+        switch(primitiveValue->getIdent())
+        {
+        case CSS_VAL_COLLAPSE:
+            style->setBorderCollapse(true);
+            break;
+        case CSS_VAL_SEPARATE:
+            style->setBorderCollapse(false);
+            break;
+        default:
+            return;
+        }
+        break;
+
+    case CSS_PROP_BORDER_TOP_STYLE:
+        HANDLE_INHERIT_AND_INITIAL_WITH_VALUE(borderTopStyle, BorderTopStyle, BorderStyle)
+        if (!primitiveValue) return;
+        style->setBorderTopStyle((EBorderStyle)(primitiveValue->getIdent() - CSS_VAL__KHTML_NATIVE));
+        break;
+    case CSS_PROP_BORDER_RIGHT_STYLE:
+        HANDLE_INHERIT_AND_INITIAL_WITH_VALUE(borderRightStyle, BorderRightStyle, BorderStyle)
+        if (!primitiveValue) return;
+        style->setBorderRightStyle((EBorderStyle)(primitiveValue->getIdent() - CSS_VAL__KHTML_NATIVE));
+        break;
+    case CSS_PROP_BORDER_BOTTOM_STYLE:
+        HANDLE_INHERIT_AND_INITIAL_WITH_VALUE(borderBottomStyle, BorderBottomStyle, BorderStyle)
+        if (!primitiveValue) return;
+        style->setBorderBottomStyle((EBorderStyle)(primitiveValue->getIdent() - CSS_VAL__KHTML_NATIVE));
+        break;
+    case CSS_PROP_BORDER_LEFT_STYLE:
+        HANDLE_INHERIT_AND_INITIAL_WITH_VALUE(borderLeftStyle, BorderLeftStyle, BorderStyle)
+        if (!primitiveValue) return;
+        style->setBorderLeftStyle((EBorderStyle)(primitiveValue->getIdent() - CSS_VAL__KHTML_NATIVE));
+        break;
+    case CSS_PROP_OUTLINE_STYLE:
+        HANDLE_INHERIT_AND_INITIAL_WITH_VALUE(outlineStyle, OutlineStyle, BorderStyle)
+        if (!primitiveValue) return;
+        style->setOutlineStyle((EBorderStyle)(primitiveValue->getIdent() - CSS_VAL__KHTML_NATIVE));
+        break;
+    case CSS_PROP_CAPTION_SIDE:
+    {
+        HANDLE_INHERIT_AND_INITIAL(captionSide, CaptionSide)
+        if(!primitiveValue) break;
+        ECaptionSide c = RenderStyle::initialCaptionSide();
+        switch(primitiveValue->getIdent())
+        {
+        case CSS_VAL_LEFT:
+            c = CAPLEFT; break;
+        case CSS_VAL_RIGHT:
+            c = CAPRIGHT; break;
+        case CSS_VAL_TOP:
+            c = CAPTOP; break;
+        case CSS_VAL_BOTTOM:
+            c = CAPBOTTOM; break;
+        default:
+            return;
+        }
+        style->setCaptionSide(c);
+        return;
+    }
+    case CSS_PROP_CLEAR:
+    {
+        HANDLE_INHERIT_AND_INITIAL(clear, Clear)
+        if(!primitiveValue) break;
+        EClear c = CNONE;
+        switch(primitiveValue->getIdent())
+        {
+        case CSS_VAL_LEFT:
+            c = CLEFT; break;
+        case CSS_VAL_RIGHT:
+            c = CRIGHT; break;
+        case CSS_VAL_BOTH:
+            c = CBOTH; break;
+        case CSS_VAL_NONE:
+            c = CNONE; break;
+        default:
+            return;
+        }
+        style->setClear(c);
+        return;
+    }
+    case CSS_PROP_DIRECTION:
+    {
+        HANDLE_INHERIT_AND_INITIAL(direction, Direction)
+        if(!primitiveValue) break;
+        style->setDirection( (EDirection) (primitiveValue->getIdent() - CSS_VAL_LTR) );
+        return;
+    }
+    case CSS_PROP_DISPLAY:
+    {
+        HANDLE_INHERIT_AND_INITIAL(display, Display)
+        if(!primitiveValue) break;
+	int id = primitiveValue->getIdent();
+        style->setDisplay( id == CSS_VAL_NONE ? NONE : EDisplay(id - CSS_VAL_INLINE) );
+        break;
+    }
+
+    case CSS_PROP_EMPTY_CELLS:
+    {
+        HANDLE_INHERIT(emptyCells, EmptyCells);
+        if (!primitiveValue) break;
+        int id = primitiveValue->getIdent();
+        if (id == CSS_VAL_SHOW)
+            style->setEmptyCells(SHOW);
+        else if (id == CSS_VAL_HIDE)
+            style->setEmptyCells(HIDE);
+        break;
+    }
+    case CSS_PROP_FLOAT:
+    {
+        HANDLE_INHERIT_AND_INITIAL(floating, Floating)
+        if(!primitiveValue) return;
+        EFloat f;
+        switch(primitiveValue->getIdent())
+        {
+        case CSS_VAL__KHTML_LEFT:
+            f = FLEFT_ALIGN; break;
+        case CSS_VAL_LEFT:
+            f = FLEFT; break;
+        case CSS_VAL__KHTML_RIGHT:
+            f = FRIGHT_ALIGN; break;
+        case CSS_VAL_RIGHT:
+            f = FRIGHT; break;
+        case CSS_VAL_NONE:
+        case CSS_VAL_CENTER:  //Non standart CSS-Value
+            f = FNONE; break;
+        default:
+            return;
+        }
+        if (f!=FNONE && style->display()==LIST_ITEM)
+            style->setDisplay(BLOCK);
+
+        style->setFloating(f);
+        break;
+    }
+
+    case CSS_PROP_FONT_STYLE:
+    {
+        FontDef fontDef = style->htmlFont().fontDef;
+        if (isInherit)
+            fontDef.italic = parentStyle->htmlFont().fontDef.italic;
+	else if (isInitial)
+            fontDef.italic = false;
+        else {
+	    if(!primitiveValue) return;
+	    switch(primitiveValue->getIdent()) {
+		case CSS_VAL_OBLIQUE:
+		// ### oblique is the same as italic for the moment...
+		case CSS_VAL_ITALIC:
+		    fontDef.italic = true;
+		    break;
+		case CSS_VAL_NORMAL:
+		    fontDef.italic = false;
+		    break;
+		default:
+		    return;
+	    }
+	}
+        fontDirty |= style->setFontDef( fontDef );
+        break;
+    }
+
+
+    case CSS_PROP_FONT_VARIANT:
+    {
+        FontDef fontDef = style->htmlFont().fontDef;
+        if (isInherit)
+            fontDef.smallCaps = parentStyle->htmlFont().fontDef.smallCaps;
+        else if (isInitial)
+            fontDef.smallCaps = false;
+        else {
+	    if(!primitiveValue) return;
+	    int id = primitiveValue->getIdent();
+	    if ( id == CSS_VAL_NORMAL )
+		fontDef.smallCaps = false;
+	    else if ( id == CSS_VAL_SMALL_CAPS )
+		fontDef.smallCaps = true;
+	    else
+		return;
+	}
+	fontDirty |= style->setFontDef( fontDef );
+	break;
+    }
+
+    case CSS_PROP_FONT_WEIGHT:
+    {
+        FontDef fontDef = style->htmlFont().fontDef;
+        if (isInherit)
+            fontDef.weight = parentStyle->htmlFont().fontDef.weight;
+        else if (isInitial)
+            fontDef.weight = TQFont::Normal;
+        else {
+	    if(!primitiveValue) return;
+	    if(primitiveValue->getIdent())
+	    {
+		switch(primitiveValue->getIdent()) {
+		    // ### we just support normal and bold fonts at the moment...
+		    // setWeight can actually accept values between 0 and 99...
+		case CSS_VAL_BOLD:
+		case CSS_VAL_BOLDER:
+		case CSS_VAL_600:
+		case CSS_VAL_700:
+		case CSS_VAL_800:
+		case CSS_VAL_900:
+		    fontDef.weight = TQFont::Bold;
+		    break;
+		case CSS_VAL_NORMAL:
+		case CSS_VAL_LIGHTER:
+		case CSS_VAL_100:
+		case CSS_VAL_200:
+		case CSS_VAL_300:
+		case CSS_VAL_400:
+		case CSS_VAL_500:
+		    fontDef.weight = TQFont::Normal;
+		    break;
+		default:
+		    return;
+		}
+	    }
+	    else
+	    {
+		// ### fix parsing of 100-900 values in parser, apply them here
+	    }
+	}
+        fontDirty |= style->setFontDef( fontDef );
+        break;
+    }
+
+    case CSS_PROP_LIST_STYLE_POSITION:
+    {
+        HANDLE_INHERIT_AND_INITIAL(listStylePosition, ListStylePosition)
+        if (!primitiveValue) return;
+        if (primitiveValue->getIdent())
+            style->setListStylePosition( (EListStylePosition) (primitiveValue->getIdent() - CSS_VAL_OUTSIDE) );
+        return;
+    }
+
+    case CSS_PROP_LIST_STYLE_TYPE:
+    {
+        HANDLE_INHERIT_AND_INITIAL(listStyleType, ListStyleType)
+        if (!primitiveValue) return;
+        if (primitiveValue->getIdent())
+        {
+            EListStyleType t;
+	    int id = primitiveValue->getIdent();
+	    if ( id == CSS_VAL_NONE) { // important!!
+	      t = LNONE;
+	    } else {
+	      t = EListStyleType(id - CSS_VAL_DISC);
+	    }
+            style->setListStyleType(t);
+        }
+        return;
+    }
+
+    case CSS_PROP_OVERFLOW:
+    {
+        if (isInherit) {
+            style->setOverflowX(parentStyle->overflowX());
+            style->setOverflowY(parentStyle->overflowY());
+            return;
+        }
+
+        if (isInitial) {
+            style->setOverflowX(RenderStyle::initialOverflowX());
+            style->setOverflowY(RenderStyle::initialOverflowY());
+            return;
+        }
+
+        if (!primitiveValue) return;
+        EOverflow o;
+        switch(primitiveValue->getIdent())
+        {
+        case CSS_VAL_VISIBLE:
+            o = OVISIBLE; break;
+        case CSS_VAL_HIDDEN:
+            o = OHIDDEN; break;
+        case CSS_VAL_SCROLL:
+	    o = OSCROLL; break;
+        case CSS_VAL_AUTO:
+	    o = OAUTO; break;
+        case CSS_VAL_MARQUEE:
+            o = OMARQUEE; break;
+        default:
+            return;
+        }
+        style->setOverflowX(o);
+        style->setOverflowY(o);
+        return;
+    }
+    case CSS_PROP_OVERFLOW_X:
+    {
+        HANDLE_INHERIT_AND_INITIAL(overflowX, OverflowX)
+        if (!primitiveValue) return;
+        EOverflow o;
+        switch(primitiveValue->getIdent())
+        {
+        case CSS_VAL_VISIBLE:
+            o = OVISIBLE; break;
+        case CSS_VAL_HIDDEN:
+            o = OHIDDEN; break;
+        case CSS_VAL_SCROLL:
+	    o = OSCROLL; break;
+        case CSS_VAL_AUTO:
+	    o = OAUTO; break;
+        default:
+            return;
+        }
+        style->setOverflowX(o);
+        return;
+    }
+    case CSS_PROP_OVERFLOW_Y:
+    {
+        HANDLE_INHERIT_AND_INITIAL(overflowY, OverflowY)
+        if (!primitiveValue) return;
+        EOverflow o;
+        switch(primitiveValue->getIdent())
+        {
+        case CSS_VAL_VISIBLE:
+            o = OVISIBLE; break;
+        case CSS_VAL_HIDDEN:
+            o = OHIDDEN; break;
+        case CSS_VAL_SCROLL:
+            o = OSCROLL; break;
+        case CSS_VAL_AUTO:
+            o = OAUTO; break;
+        default:
+            return;
+        }
+        style->setOverflowY(o);
+        return;
+    }
+    case CSS_PROP_PAGE_BREAK_BEFORE:
+    {
+        HANDLE_INHERIT_AND_INITIAL_WITH_VALUE(pageBreakBefore, PageBreakBefore, PageBreak)
+        if (!primitiveValue) return;
+        switch (primitiveValue->getIdent()) {
+            case CSS_VAL_AUTO:
+                style->setPageBreakBefore(PBAUTO);
+                break;
+            case CSS_VAL_LEFT:
+            case CSS_VAL_RIGHT:
+                // CSS2.1: "Conforming user agents may map left/right to always."
+            case CSS_VAL_ALWAYS:
+                style->setPageBreakBefore(PBALWAYS);
+                break;
+            case CSS_VAL_AVOID:
+                style->setPageBreakBefore(PBAVOID);
+                break;
+        }
+        break;
+    }
+
+    case CSS_PROP_PAGE_BREAK_AFTER:
+    {
+        HANDLE_INHERIT_AND_INITIAL_WITH_VALUE(pageBreakAfter, PageBreakAfter, PageBreak)
+        if (!primitiveValue) return;
+        switch (primitiveValue->getIdent()) {
+            case CSS_VAL_AUTO:
+                style->setPageBreakAfter(PBAUTO);
+                break;
+            case CSS_VAL_LEFT:
+            case CSS_VAL_RIGHT:
+                // CSS2.1: "Conforming user agents may map left/right to always."
+            case CSS_VAL_ALWAYS:
+                style->setPageBreakAfter(PBALWAYS);
+                break;
+            case CSS_VAL_AVOID:
+                style->setPageBreakAfter(PBAVOID);
+                break;
+        }
+        break;
+    }
+
+    case CSS_PROP_PAGE_BREAK_INSIDE: {
+        HANDLE_INHERIT_AND_INITIAL(pageBreakInside, PageBreakInside)
+        if (!primitiveValue) return;
+        if (primitiveValue->getIdent() == CSS_VAL_AUTO)
+            style->setPageBreakInside(true);
+        else if (primitiveValue->getIdent() == CSS_VAL_AVOID)
+            style->setPageBreakInside(false);
+        return;
+    }
+//    case CSS_PROP_PAUSE_AFTER:
+//    case CSS_PROP_PAUSE_BEFORE:
+        break;
+
+    case CSS_PROP_POSITION:
+    {
+        HANDLE_INHERIT_AND_INITIAL(position, Position)
+        if (!primitiveValue) return;
+        EPosition p;
+        switch(primitiveValue->getIdent())
+        {
+        case CSS_VAL_STATIC:
+            p = STATIC; break;
+        case CSS_VAL_RELATIVE:
+            p = RELATIVE; break;
+        case CSS_VAL_ABSOLUTE:
+            p = ABSOLUTE; break;
+        case CSS_VAL_FIXED:
+            {
+                view->useSlowRepaints();
+                p = FIXED;
+                break;
+            }
+        default:
+            return;
+        }
+        style->setPosition(p);
+        return;
+    }
+
+    case CSS_PROP_TABLE_LAYOUT: {
+        HANDLE_INHERIT_AND_INITIAL(tableLayout, TableLayout)
+
+	if ( !primitiveValue )
+	    return;
+
+	ETableLayout l = RenderStyle::initialTableLayout();
+	switch( primitiveValue->getIdent() ) {
+	case CSS_VAL_FIXED:
+	    l = TFIXED;
+	    // fall through
+	case CSS_VAL_AUTO:
+	    style->setTableLayout( l );
+	default:
+	    break;
+	}
+	break;
+    }
+
+    case CSS_PROP_UNICODE_BIDI: {
+        HANDLE_INHERIT_AND_INITIAL(unicodeBidi, UnicodeBidi)
+        if(!primitiveValue) break;
+        switch (primitiveValue->getIdent()) {
+            case CSS_VAL_NORMAL:
+                style->setUnicodeBidi(UBNormal);
+                break;
+            case CSS_VAL_EMBED:
+                style->setUnicodeBidi(Embed);
+                break;
+            case CSS_VAL_BIDI_OVERRIDE:
+                style->setUnicodeBidi(Override);
+                break;
+            default:
+                return;
+        }
+	break;
+    }
+    case CSS_PROP_TEXT_TRANSFORM: {
+        HANDLE_INHERIT_AND_INITIAL(textTransform, TextTransform)
+
+        if(!primitiveValue) break;
+        if(!primitiveValue->getIdent()) return;
+
+        ETextTransform tt;
+        switch(primitiveValue->getIdent()) {
+        case CSS_VAL_CAPITALIZE:  tt = CAPITALIZE;  break;
+        case CSS_VAL_UPPERCASE:   tt = UPPERCASE;   break;
+        case CSS_VAL_LOWERCASE:   tt = LOWERCASE;   break;
+        case CSS_VAL_NONE:
+        default:                  tt = TTNONE;      break;
+        }
+        style->setTextTransform(tt);
+        break;
+        }
+
+    case CSS_PROP_VISIBILITY:
+    {
+        HANDLE_INHERIT_AND_INITIAL(visibility, Visibility)
+
+        if(!primitiveValue) break;
+        switch( primitiveValue->getIdent() ) {
+        case CSS_VAL_HIDDEN:
+            style->setVisibility( HIDDEN );
+            break;
+        case CSS_VAL_VISIBLE:
+            style->setVisibility( VISIBLE );
+            break;
+        case CSS_VAL_COLLAPSE:
+            style->setVisibility( COLLAPSE );
+        default:
+            break;
+        }
+        break;
+    }
+    case CSS_PROP_WHITE_SPACE:
+        HANDLE_INHERIT_AND_INITIAL(whiteSpace, WhiteSpace)
+
+        if(!primitiveValue) break;
+        if(!primitiveValue->getIdent()) return;
+
+        EWhiteSpace s;
+        switch(primitiveValue->getIdent()) {
+        case CSS_VAL__KHTML_NOWRAP:
+            s = KHTML_NOWRAP;
+            break;
+        case CSS_VAL_NOWRAP:
+            s = NOWRAP;
+            break;
+        case CSS_VAL_PRE:
+            s = PRE;
+            break;
+        case CSS_VAL_PRE_WRAP:
+            s = PRE_WRAP;
+            break;
+        case CSS_VAL_PRE_LINE:
+            s = PRE_LINE;
+            break;
+        case CSS_VAL_NORMAL:
+        default:
+            s = NORMAL;
+            break;
+        }
+        style->setWhiteSpace(s);
+        break;
+
+    case CSS_PROP_BACKGROUND_POSITION:
+        HANDLE_BACKGROUND_INHERIT_AND_INITIAL(backgroundXPosition, BackgroundXPosition);
+        HANDLE_BACKGROUND_INHERIT_AND_INITIAL(backgroundYPosition, BackgroundYPosition);
+        break;
+    case CSS_PROP_BACKGROUND_POSITION_X: {
+        HANDLE_BACKGROUND_VALUE(backgroundXPosition, BackgroundXPosition, value)
+        break;
+    }
+    case CSS_PROP_BACKGROUND_POSITION_Y: {
+        HANDLE_BACKGROUND_VALUE(backgroundYPosition, BackgroundYPosition, value)
+        break;
+    }
+    case CSS_PROP_BORDER_SPACING: {
+        if(value->cssValueType() != CSSValue::CSS_INHERIT || !parentNode) return;
+        style->setBorderHorizontalSpacing(parentStyle->borderHorizontalSpacing());
+        style->setBorderVerticalSpacing(parentStyle->borderVerticalSpacing());
+        break;
+    }
+    case CSS_PROP__KHTML_BORDER_HORIZONTAL_SPACING: {
+        HANDLE_INHERIT_AND_INITIAL(borderHorizontalSpacing, BorderHorizontalSpacing)
+        if (!primitiveValue) break;
+        short spacing =  primitiveValue->computeLength(style, paintDeviceMetrics);
+        style->setBorderHorizontalSpacing(spacing);
+        break;
+    }
+    case CSS_PROP__KHTML_BORDER_VERTICAL_SPACING: {
+        HANDLE_INHERIT_AND_INITIAL(borderVerticalSpacing, BorderVerticalSpacing)
+        if (!primitiveValue) break;
+        short spacing =  primitiveValue->computeLength(style, paintDeviceMetrics);
+        style->setBorderVerticalSpacing(spacing);
+        break;
+    }
+
+    case CSS_PROP_CURSOR:
+        HANDLE_INHERIT_AND_INITIAL(cursor, Cursor)
+        if(primitiveValue)
+	    style->setCursor( (ECursor) (primitiveValue->getIdent() - CSS_VAL_AUTO) );
+        break;
+// colors || inherit
+    case CSS_PROP_BACKGROUND_COLOR:
+    case CSS_PROP_BORDER_TOP_COLOR:
+    case CSS_PROP_BORDER_RIGHT_COLOR:
+    case CSS_PROP_BORDER_BOTTOM_COLOR:
+    case CSS_PROP_BORDER_LEFT_COLOR:
+    case CSS_PROP_COLOR:
+    case CSS_PROP_OUTLINE_COLOR:
+        // this property is an extension used to get HTML4 <font> right.
+	case CSS_PROP_SCROLLBAR_BASE_COLOR:
+    case CSS_PROP_SCROLLBAR_FACE_COLOR:
+    case CSS_PROP_SCROLLBAR_SHADOW_COLOR:
+    case CSS_PROP_SCROLLBAR_HIGHLIGHT_COLOR:
+    case CSS_PROP_SCROLLBAR_3DLIGHT_COLOR:
+    case CSS_PROP_SCROLLBAR_DARKSHADOW_COLOR:
+    case CSS_PROP_SCROLLBAR_TRACK_COLOR:
+    case CSS_PROP_SCROLLBAR_ARROW_COLOR:
+    {
+        TQColor col;
+        if (isInherit) {
+            HANDLE_INHERIT_COND(CSS_PROP_BACKGROUND_COLOR, backgroundColor, BackgroundColor)
+            HANDLE_INHERIT_COND(CSS_PROP_BORDER_TOP_COLOR, borderTopColor, BorderTopColor)
+            HANDLE_INHERIT_COND(CSS_PROP_BORDER_BOTTOM_COLOR, borderBottomColor, BorderBottomColor)
+            HANDLE_INHERIT_COND(CSS_PROP_BORDER_RIGHT_COLOR, borderRightColor, BorderRightColor)
+            HANDLE_INHERIT_COND(CSS_PROP_BORDER_LEFT_COLOR, borderLeftColor, BorderLeftColor)
+            HANDLE_INHERIT_COND(CSS_PROP_COLOR, color, Color)
+            HANDLE_INHERIT_COND(CSS_PROP_OUTLINE_COLOR, outlineColor, OutlineColor)
+            return;
+        } else if (isInitial) {
+            // The border/outline colors will just map to the invalid color |col| above.  This will have the
+            // effect of forcing the use of the currentColor when it comes time to draw the borders (and of
+            // not painting the background since the color won't be valid).
+            if (id == CSS_PROP_COLOR)
+                col = RenderStyle::initialColor();
+        } else {
+	    if(!primitiveValue )
+		return;
+	    int ident = primitiveValue->getIdent();
+	    if ( ident ) {
+		if ( ident == CSS_VAL__KHTML_TEXT )
+		    col = element->getDocument()->textColor();
+  		// ### should be eliminated
+		else if ( ident == CSS_VAL_TRANSPARENT
+                	&& id != CSS_PROP_BORDER_TOP_COLOR
+                        && id != CSS_PROP_BORDER_RIGHT_COLOR
+      			&& id != CSS_PROP_BORDER_BOTTOM_COLOR
+      			&& id != CSS_PROP_BORDER_LEFT_COLOR )
+		    col = TQColor();
+		else
+		    col = colorForCSSValue( ident );
+	    } else if ( primitiveValue->primitiveType() == CSSPrimitiveValue::CSS_RGBCOLOR ) {
+#ifndef APPLE_CHANGES
+		if(tqAlpha(primitiveValue->getRGBColorValue()))
+#endif
+		    col.setRgb(primitiveValue->getRGBColorValue());
+	    } else {
+		return;
+	    }
+	}
+        //kdDebug( 6080 ) << "applying color " << col.isValid() << endl;
+        switch(id)
+        {
+        case CSS_PROP_BACKGROUND_COLOR:
+	    style->setBackgroundColor(col); break;
+        case CSS_PROP_BORDER_TOP_COLOR:
+            style->setBorderTopColor(col); break;
+        case CSS_PROP_BORDER_RIGHT_COLOR:
+            style->setBorderRightColor(col); break;
+        case CSS_PROP_BORDER_BOTTOM_COLOR:
+            style->setBorderBottomColor(col); break;
+        case CSS_PROP_BORDER_LEFT_COLOR:
+            style->setBorderLeftColor(col); break;
+        case CSS_PROP_COLOR:
+            style->setColor(col); break;
+        case CSS_PROP_OUTLINE_COLOR:
+            style->setOutlineColor(col); break;
+#ifndef APPLE_CHANGES
+        case CSS_PROP_SCROLLBAR_FACE_COLOR:
+            style->setPaletteColor(TQPalette::Active, TQColorGroup::Button, col);
+            style->setPaletteColor(TQPalette::Inactive, TQColorGroup::Button, col);
+            break;
+        case CSS_PROP_SCROLLBAR_SHADOW_COLOR:
+            style->setPaletteColor(TQPalette::Active, TQColorGroup::Shadow, col);
+            style->setPaletteColor(TQPalette::Inactive, TQColorGroup::Shadow, col);
+            break;
+        case CSS_PROP_SCROLLBAR_HIGHLIGHT_COLOR:
+            style->setPaletteColor(TQPalette::Active, TQColorGroup::Light, col);
+            style->setPaletteColor(TQPalette::Inactive, TQColorGroup::Light, col);
+            break;
+        case CSS_PROP_SCROLLBAR_3DLIGHT_COLOR:
+            break;
+        case CSS_PROP_SCROLLBAR_DARKSHADOW_COLOR:
+            style->setPaletteColor(TQPalette::Active, TQColorGroup::Dark, col);
+            style->setPaletteColor(TQPalette::Inactive, TQColorGroup::Dark, col);
+            break;
+        case CSS_PROP_SCROLLBAR_TRACK_COLOR:
+            style->setPaletteColor(TQPalette::Active, TQColorGroup::Mid, col);
+            style->setPaletteColor(TQPalette::Inactive, TQColorGroup::Mid, col);
+            style->setPaletteColor(TQPalette::Active, TQColorGroup::Background, col);
+            style->setPaletteColor(TQPalette::Inactive, TQColorGroup::Background, col);
+            // fall through
+        case CSS_PROP_SCROLLBAR_BASE_COLOR:
+            style->setPaletteColor(TQPalette::Active, TQColorGroup::Base, col);
+            style->setPaletteColor(TQPalette::Inactive, TQColorGroup::Base, col);
+            break;
+        case CSS_PROP_SCROLLBAR_ARROW_COLOR:
+            style->setPaletteColor(TQPalette::Active, TQColorGroup::ButtonText, col);
+            style->setPaletteColor(TQPalette::Inactive, TQColorGroup::ButtonText, col);
+            break;
+#endif
+        default:
+            return;
+        }
+        return;
+    }
+    break;
+// uri || inherit
+    case CSS_PROP_BACKGROUND_IMAGE:
+        HANDLE_BACKGROUND_VALUE(backgroundImage, BackgroundImage, value)
+        break;
+    case CSS_PROP_LIST_STYLE_IMAGE:
+    {
+        HANDLE_INHERIT_AND_INITIAL(listStyleImage, ListStyleImage)
+        if (!primitiveValue) return;
+	style->setListStyleImage(static_cast<CSSImageValueImpl *>(primitiveValue)->image());
+        //kdDebug( 6080 ) << "setting image in list to " << image->image() << endl;
+        break;
+    }
+
+// length
+    case CSS_PROP_BORDER_TOP_WIDTH:
+    case CSS_PROP_BORDER_RIGHT_WIDTH:
+    case CSS_PROP_BORDER_BOTTOM_WIDTH:
+    case CSS_PROP_BORDER_LEFT_WIDTH:
+    case CSS_PROP_OUTLINE_WIDTH:
+    {
+	if (isInherit) {
+            HANDLE_INHERIT_COND(CSS_PROP_BORDER_TOP_WIDTH, borderTopWidth, BorderTopWidth)
+            HANDLE_INHERIT_COND(CSS_PROP_BORDER_RIGHT_WIDTH, borderRightWidth, BorderRightWidth)
+            HANDLE_INHERIT_COND(CSS_PROP_BORDER_BOTTOM_WIDTH, borderBottomWidth, BorderBottomWidth)
+            HANDLE_INHERIT_COND(CSS_PROP_BORDER_LEFT_WIDTH, borderLeftWidth, BorderLeftWidth)
+            HANDLE_INHERIT_COND(CSS_PROP_OUTLINE_WIDTH, outlineWidth, OutlineWidth)
+            return;
+        }
+        else if (isInitial) {
+            HANDLE_INITIAL_COND_WITH_VALUE(CSS_PROP_BORDER_TOP_WIDTH, BorderTopWidth, BorderWidth)
+            HANDLE_INITIAL_COND_WITH_VALUE(CSS_PROP_BORDER_RIGHT_WIDTH, BorderRightWidth, BorderWidth)
+            HANDLE_INITIAL_COND_WITH_VALUE(CSS_PROP_BORDER_BOTTOM_WIDTH, BorderBottomWidth, BorderWidth)
+            HANDLE_INITIAL_COND_WITH_VALUE(CSS_PROP_BORDER_LEFT_WIDTH, BorderLeftWidth, BorderWidth)
+            HANDLE_INITIAL_COND_WITH_VALUE(CSS_PROP_OUTLINE_WIDTH, OutlineWidth, BorderWidth)
+            return;
+        }
+
+        if(!primitiveValue) break;
+        short width = 3;
+        switch(primitiveValue->getIdent())
+        {
+        case CSS_VAL_THIN:
+            width = 1;
+            break;
+        case CSS_VAL_MEDIUM:
+            width = 3;
+            break;
+        case CSS_VAL_THICK:
+            width = 5;
+            break;
+        case CSS_VAL_INVALID:
+        {
+            double widthd = primitiveValue->computeLengthFloat(style, paintDeviceMetrics);
+            width = (int)widthd;
+            // somewhat resemble Mozilla's granularity
+            // this makes border-width: 0.5pt borders visible
+            if (width == 0 && widthd >= 0.025) width++;
+            break;
+        }
+        default:
+            return;
+        }
+
+        if(width < 0) return;
+        switch(id)
+        {
+        case CSS_PROP_BORDER_TOP_WIDTH:
+            style->setBorderTopWidth(width);
+            break;
+        case CSS_PROP_BORDER_RIGHT_WIDTH:
+            style->setBorderRightWidth(width);
+            break;
+        case CSS_PROP_BORDER_BOTTOM_WIDTH:
+            style->setBorderBottomWidth(width);
+            break;
+        case CSS_PROP_BORDER_LEFT_WIDTH:
+            style->setBorderLeftWidth(width);
+            break;
+        case CSS_PROP_OUTLINE_WIDTH:
+            style->setOutlineWidth(width);
+            break;
+        default:
+            return;
+        }
+        return;
+    }
+
+    case CSS_PROP_LETTER_SPACING:
+    case CSS_PROP_WORD_SPACING:
+    {
+        if (isInherit) {
+            HANDLE_INHERIT_COND(CSS_PROP_LETTER_SPACING, letterSpacing, LetterSpacing)
+            HANDLE_INHERIT_COND(CSS_PROP_WORD_SPACING, wordSpacing, WordSpacing)
+            return;
+        } else if (isInitial) {
+            HANDLE_INITIAL_COND_WITH_VALUE(CSS_PROP_LETTER_SPACING, LetterSpacing, LetterWordSpacing)
+            HANDLE_INITIAL_COND_WITH_VALUE(CSS_PROP_WORD_SPACING, WordSpacing, LetterWordSpacing)
+            return;
+        }
+        if(!primitiveValue) return;
+
+        int width = 0;
+        if (primitiveValue->getIdent() != CSS_VAL_NORMAL)
+	    width = primitiveValue->computeLength(style, paintDeviceMetrics);
+
+        switch(id)
+        {
+        case CSS_PROP_LETTER_SPACING:
+            style->setLetterSpacing(width);
+            break;
+        case CSS_PROP_WORD_SPACING:
+            style->setWordSpacing(width);
+            break;
+            // ### needs the definitions in renderstyle
+        default: break;
+        }
+        return;
+    }
+
+        // length, percent
+    case CSS_PROP_MAX_WIDTH:
+        // +none +inherit
+        if(primitiveValue && primitiveValue->getIdent() == CSS_VAL_NONE) {
+            apply = true;
+            l = Length(UNDEFINED, Fixed);
+        }
+    case CSS_PROP_TOP:
+    case CSS_PROP_LEFT:
+    case CSS_PROP_RIGHT:
+    case CSS_PROP_BOTTOM:
+    case CSS_PROP_WIDTH:
+    case CSS_PROP_MIN_WIDTH:
+    case CSS_PROP_MARGIN_TOP:
+    case CSS_PROP_MARGIN_RIGHT:
+    case CSS_PROP_MARGIN_BOTTOM:
+    case CSS_PROP_MARGIN_LEFT:
+        // +inherit +auto
+        if(id != CSS_PROP_MAX_WIDTH && primitiveValue &&
+           primitiveValue->getIdent() == CSS_VAL_AUTO)
+        {
+            //kdDebug( 6080 ) << "found value=auto" << endl;
+            apply = true;
+        }
+    case CSS_PROP_PADDING_TOP:
+    case CSS_PROP_PADDING_RIGHT:
+    case CSS_PROP_PADDING_BOTTOM:
+    case CSS_PROP_PADDING_LEFT:
+    case CSS_PROP_TEXT_INDENT:
+        // +inherit
+    {
+        if (isInherit) {
+            HANDLE_INHERIT_COND(CSS_PROP_MAX_WIDTH, maxWidth, MaxWidth)
+            HANDLE_INHERIT_COND(CSS_PROP_BOTTOM, bottom, Bottom)
+            HANDLE_INHERIT_COND(CSS_PROP_TOP, top, Top)
+            HANDLE_INHERIT_COND(CSS_PROP_LEFT, left, Left)
+            HANDLE_INHERIT_COND(CSS_PROP_RIGHT, right, Right)
+            HANDLE_INHERIT_COND(CSS_PROP_WIDTH, width, Width)
+            HANDLE_INHERIT_COND(CSS_PROP_MIN_WIDTH, minWidth, MinWidth)
+            HANDLE_INHERIT_COND(CSS_PROP_PADDING_TOP, paddingTop, PaddingTop)
+            HANDLE_INHERIT_COND(CSS_PROP_PADDING_RIGHT, paddingRight, PaddingRight)
+            HANDLE_INHERIT_COND(CSS_PROP_PADDING_BOTTOM, paddingBottom, PaddingBottom)
+            HANDLE_INHERIT_COND(CSS_PROP_PADDING_LEFT, paddingLeft, PaddingLeft)
+            HANDLE_INHERIT_COND(CSS_PROP_MARGIN_TOP, marginTop, MarginTop)
+            HANDLE_INHERIT_COND(CSS_PROP_MARGIN_RIGHT, marginRight, MarginRight)
+            HANDLE_INHERIT_COND(CSS_PROP_MARGIN_BOTTOM, marginBottom, MarginBottom)
+            HANDLE_INHERIT_COND(CSS_PROP_MARGIN_LEFT, marginLeft, MarginLeft)
+            HANDLE_INHERIT_COND(CSS_PROP_TEXT_INDENT, textIndent, TextIndent)
+            return;
+        } else if (isInitial) {
+            HANDLE_INITIAL_COND_WITH_VALUE(CSS_PROP_MAX_WIDTH, MaxWidth, MaxSize)
+            HANDLE_INITIAL_COND_WITH_VALUE(CSS_PROP_BOTTOM, Bottom, Offset)
+            HANDLE_INITIAL_COND_WITH_VALUE(CSS_PROP_TOP, Top, Offset)
+            HANDLE_INITIAL_COND_WITH_VALUE(CSS_PROP_LEFT, Left, Offset)
+            HANDLE_INITIAL_COND_WITH_VALUE(CSS_PROP_RIGHT, Right, Offset)
+            HANDLE_INITIAL_COND_WITH_VALUE(CSS_PROP_WIDTH, Width, Size)
+            HANDLE_INITIAL_COND_WITH_VALUE(CSS_PROP_MIN_WIDTH, MinWidth, MinSize)
+            HANDLE_INITIAL_COND_WITH_VALUE(CSS_PROP_PADDING_TOP, PaddingTop, Padding)
+            HANDLE_INITIAL_COND_WITH_VALUE(CSS_PROP_PADDING_RIGHT, PaddingRight, Padding)
+            HANDLE_INITIAL_COND_WITH_VALUE(CSS_PROP_PADDING_BOTTOM, PaddingBottom, Padding)
+            HANDLE_INITIAL_COND_WITH_VALUE(CSS_PROP_PADDING_LEFT, PaddingLeft, Padding)
+            HANDLE_INITIAL_COND_WITH_VALUE(CSS_PROP_MARGIN_TOP, MarginTop, Margin)
+            HANDLE_INITIAL_COND_WITH_VALUE(CSS_PROP_MARGIN_RIGHT, MarginRight, Margin)
+            HANDLE_INITIAL_COND_WITH_VALUE(CSS_PROP_MARGIN_BOTTOM, MarginBottom, Margin)
+            HANDLE_INITIAL_COND_WITH_VALUE(CSS_PROP_MARGIN_LEFT, MarginLeft, Margin)
+            HANDLE_INITIAL_COND(CSS_PROP_TEXT_INDENT, TextIndent)
+            return;
+        }
+
+        if (primitiveValue && !apply) {
+            int type = primitiveValue->primitiveType();
+            if(type > CSSPrimitiveValue::CSS_PERCENTAGE && type < CSSPrimitiveValue::CSS_DEG)
+                // Handle our quirky margin units if we have them.
+                l = Length(primitiveValue->computeLength(style, paintDeviceMetrics), Fixed,
+                           primitiveValue->isQuirkValue());
+            else if(type == CSSPrimitiveValue::CSS_PERCENTAGE)
+                l = Length((int)primitiveValue->floatValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);
+	    else if (type == CSSPrimitiveValue::CSS_HTML_RELATIVE)
+		l = Length(int(primitiveValue->floatValue(CSSPrimitiveValue::CSS_HTML_RELATIVE)), Relative);
+            else
+                return;
+            apply = true;
+        }
+        if(!apply) return;
+        switch(id)
+            {
+            case CSS_PROP_MAX_WIDTH:
+                style->setMaxWidth(l); break;
+            case CSS_PROP_BOTTOM:
+                style->setBottom(l); break;
+            case CSS_PROP_TOP:
+                style->setTop(l); break;
+            case CSS_PROP_LEFT:
+                style->setLeft(l); break;
+            case CSS_PROP_RIGHT:
+                style->setRight(l); break;
+            case CSS_PROP_WIDTH:
+                style->setWidth(l); break;
+            case CSS_PROP_MIN_WIDTH:
+                style->setMinWidth(l); break;
+            case CSS_PROP_PADDING_TOP:
+                style->setPaddingTop(l); break;
+            case CSS_PROP_PADDING_RIGHT:
+                style->setPaddingRight(l); break;
+            case CSS_PROP_PADDING_BOTTOM:
+                style->setPaddingBottom(l); break;
+            case CSS_PROP_PADDING_LEFT:
+                style->setPaddingLeft(l); break;
+            case CSS_PROP_MARGIN_TOP:
+                style->setMarginTop(l); break;
+            case CSS_PROP_MARGIN_RIGHT:
+                style->setMarginRight(l); break;
+            case CSS_PROP_MARGIN_BOTTOM:
+                style->setMarginBottom(l); break;
+            case CSS_PROP_MARGIN_LEFT:
+                style->setMarginLeft(l); break;
+            case CSS_PROP_TEXT_INDENT:
+                style->setTextIndent(l); break;
+            default: break;
+            }
+        return;
+    }
+
+    case CSS_PROP_MAX_HEIGHT:
+        if(primitiveValue && primitiveValue->getIdent() == CSS_VAL_NONE) {
+            apply = true;
+            l = Length(UNDEFINED, Fixed);
+        }
+    case CSS_PROP_HEIGHT:
+    case CSS_PROP_MIN_HEIGHT:
+        if(id != CSS_PROP_MAX_HEIGHT && primitiveValue &&
+           primitiveValue->getIdent() == CSS_VAL_AUTO)
+            apply = true;
+        if (isInherit) {
+            HANDLE_INHERIT_COND(CSS_PROP_MAX_HEIGHT, maxHeight, MaxHeight)
+            HANDLE_INHERIT_COND(CSS_PROP_HEIGHT, height, Height)
+            HANDLE_INHERIT_COND(CSS_PROP_MIN_HEIGHT, minHeight, MinHeight)
+            return;
+        }
+        else if (isInitial) {
+            HANDLE_INITIAL_COND_WITH_VALUE(CSS_PROP_MAX_HEIGHT, MaxHeight, MaxSize)
+            HANDLE_INITIAL_COND_WITH_VALUE(CSS_PROP_HEIGHT, Height, Size)
+            HANDLE_INITIAL_COND_WITH_VALUE(CSS_PROP_MIN_HEIGHT, MinHeight, MinSize)
+            return;
+        }
+
+        if (primitiveValue && !apply)
+        {
+            int type = primitiveValue->primitiveType();
+            if(type > CSSPrimitiveValue::CSS_PERCENTAGE && type < CSSPrimitiveValue::CSS_DEG)
+                l = Length(primitiveValue->computeLength(style, paintDeviceMetrics), Fixed);
+            else if(type == CSSPrimitiveValue::CSS_PERCENTAGE)
+                l = Length((int)primitiveValue->floatValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);
+            else
+                return;
+            apply = true;
+        }
+        if(!apply) return;
+        switch(id)
+        {
+        case CSS_PROP_MAX_HEIGHT:
+            style->setMaxHeight(l); break;
+        case CSS_PROP_HEIGHT:
+            style->setHeight(l); break;
+        case CSS_PROP_MIN_HEIGHT:
+            style->setMinHeight(l); break;
+        default:
+            return;
+        }
+        return;
+
+        break;
+
+    case CSS_PROP_VERTICAL_ALIGN:
+        HANDLE_INHERIT_AND_INITIAL(verticalAlign, VerticalAlign)
+        if (!primitiveValue) return;
+        if (primitiveValue->getIdent()) {
+	  tdehtml::EVerticalAlign align;
+
+	  switch(primitiveValue->getIdent())
+	    {
+		case CSS_VAL_TOP:
+		    align = TOP; break;
+		case CSS_VAL_BOTTOM:
+		    align = BOTTOM; break;
+		case CSS_VAL_MIDDLE:
+		    align = MIDDLE; break;
+		case CSS_VAL_BASELINE:
+		    align = BASELINE; break;
+		case CSS_VAL_TEXT_BOTTOM:
+		    align = TEXT_BOTTOM; break;
+		case CSS_VAL_TEXT_TOP:
+		    align = TEXT_TOP; break;
+		case CSS_VAL_SUB:
+		    align = SUB; break;
+		case CSS_VAL_SUPER:
+		    align = SUPER; break;
+		case CSS_VAL__KHTML_BASELINE_MIDDLE:
+		    align = BASELINE_MIDDLE; break;
+		default:
+		    return;
+	    }
+	  style->setVerticalAlign(align);
+	  return;
+        } else {
+	  int type = primitiveValue->primitiveType();
+	  Length l;
+	  if(type > CSSPrimitiveValue::CSS_PERCENTAGE && type < CSSPrimitiveValue::CSS_DEG)
+	    l = Length(primitiveValue->computeLength(style, paintDeviceMetrics), Fixed );
+	  else if(type == CSSPrimitiveValue::CSS_PERCENTAGE)
+	    l = Length( int( primitiveValue->floatValue(CSSPrimitiveValue::CSS_PERCENTAGE) ), Percent );
+
+	  style->setVerticalAlign( LENGTH );
+	  style->setVerticalAlignLength( l );
+	}
+        break;
+
+    case CSS_PROP_FONT_SIZE:
+    {
+        FontDef fontDef = style->htmlFont().fontDef;
+        int oldSize;
+        int size = 0;
+
+	float toPix = paintDeviceMetrics->logicalDpiY()/72.;
+	if (toPix  < 96./72.) toPix = 96./72.;
+
+        int minFontSize = int(settings->minFontSize() * toPix);
+
+        if(parentNode) {
+            oldSize = parentStyle->font().pixelSize();
+        } else
+            oldSize = m_fontSizes[3];
+
+        if (isInherit )
+            size = oldSize;
+        else if (isInitial)
+            size = m_fontSizes[3];
+        else if(primitiveValue->getIdent()) {
+	    // keywords are being used.  Pick the correct default
+	    // based off the font family.
+#ifdef APPLE_CHANGES
+	    const TQValueVector<int>& fontSizes = (fontDef.genericFamily == FontDef::eMonospace) ?
+					 m_fixedFontSizes : m_fontSizes;
+#else
+	    const TQValueVector<int>& fontSizes = m_fontSizes;
+#endif
+            switch(primitiveValue->getIdent())
+            {
+            case CSS_VAL_XX_SMALL: size = int( fontSizes[0] ); break;
+            case CSS_VAL_X_SMALL:  size = int( fontSizes[1] ); break;
+            case CSS_VAL_SMALL:    size = int( fontSizes[2] ); break;
+            case CSS_VAL_MEDIUM:   size = int( fontSizes[3] ); break;
+            case CSS_VAL_LARGE:    size = int( fontSizes[4] ); break;
+            case CSS_VAL_X_LARGE:  size = int( fontSizes[5] ); break;
+            case CSS_VAL_XX_LARGE: size = int( fontSizes[6] ); break;
+            case CSS_VAL__KHTML_XXX_LARGE: size = int( fontSizes[7] ); break;
+            case CSS_VAL_LARGER:
+                size = nextFontSize(fontSizes, oldSize, false);
+                break;
+            case CSS_VAL_SMALLER:
+                size = nextFontSize(fontSizes, oldSize, true);
+                break;
+            default:
+                return;
+            }
+
+        } else {
+            int type = primitiveValue->primitiveType();
+            if(type > CSSPrimitiveValue::CSS_PERCENTAGE && type < CSSPrimitiveValue::CSS_DEG) {
+                if ( !tdehtml::printpainter && type != CSSPrimitiveValue::CSS_EMS && type != CSSPrimitiveValue::CSS_EXS &&
+                     view && view->part())
+                    size = int( primitiveValue->computeLengthFloat(parentStyle, paintDeviceMetrics) *
+                                view->part()->zoomFactor() ) / 100;
+		else
+                    size = int( primitiveValue->computeLengthFloat(parentStyle, paintDeviceMetrics) );
+            }
+            else if(type == CSSPrimitiveValue::CSS_PERCENTAGE)
+                size = int(primitiveValue->floatValue(CSSPrimitiveValue::CSS_PERCENTAGE)
+                        * parentStyle->font().pixelSize()) / 100;
+            else
+                return;
+        }
+
+        if (size < 0) return;
+
+        // we never want to get smaller than the minimum font size to keep fonts readable
+        // do not however maximize zero as that is commonly used for fancy layouting purposes
+        if (size && size < minFontSize) size = minFontSize;
+
+        //kdDebug( 6080 ) << "computed raw font size: " << size << endl;
+
+	fontDef.size = size;
+        fontDirty |= style->setFontDef( fontDef );
+        return;
+    }
+
+    case CSS_PROP_Z_INDEX:
+    {
+        HANDLE_INHERIT(zIndex, ZIndex)
+        else if (isInitial) {
+            style->setHasAutoZIndex();
+            return;
+        }
+
+        if (!primitiveValue)
+            return;
+
+        if (primitiveValue->getIdent() == CSS_VAL_AUTO) {
+            style->setHasAutoZIndex();
+            return;
+        }
+
+        if (primitiveValue->primitiveType() != CSSPrimitiveValue::CSS_NUMBER)
+            return; // Error case.
+
+        style->setZIndex((int)primitiveValue->floatValue(CSSPrimitiveValue::CSS_NUMBER));
+        return;
+    }
+
+    case CSS_PROP_WIDOWS:
+    {
+        HANDLE_INHERIT_AND_INITIAL(widows, Widows)
+        if (!primitiveValue || primitiveValue->primitiveType() != CSSPrimitiveValue::CSS_NUMBER)
+            return;
+        style->setWidows((int)primitiveValue->floatValue(CSSPrimitiveValue::CSS_NUMBER));
+        break;
+     }
+
+    case CSS_PROP_ORPHANS:
+    {
+        HANDLE_INHERIT_AND_INITIAL(orphans, Orphans)
+        if (!primitiveValue || primitiveValue->primitiveType() != CSSPrimitiveValue::CSS_NUMBER)
+            return;
+        style->setOrphans((int)primitiveValue->floatValue(CSSPrimitiveValue::CSS_NUMBER));
+        break;
+    }
+
+// length, percent, number
+    case CSS_PROP_LINE_HEIGHT:
+    {
+        HANDLE_INHERIT_AND_INITIAL(lineHeight, LineHeight)
+        if(!primitiveValue) return;
+        Length lineHeight;
+        int type = primitiveValue->primitiveType();
+        if (primitiveValue->getIdent() == CSS_VAL_NORMAL)
+            lineHeight = Length( -100, Percent );
+        else if (type > CSSPrimitiveValue::CSS_PERCENTAGE && type < CSSPrimitiveValue::CSS_DEG) {
+            // Scale for the font zoom factor only for types other than "em" and "ex", since those are
+            // already based on the font size.
+		if ( !tdehtml::printpainter && type != CSSPrimitiveValue::CSS_EMS && type != CSSPrimitiveValue::CSS_EXS &&
+                    view && view->part())
+                    lineHeight = Length(primitiveValue->computeLength(style, paintDeviceMetrics) *
+                                        view->part()->zoomFactor()/100, Fixed );
+                else
+                    lineHeight = Length(primitiveValue->computeLength(style, paintDeviceMetrics), Fixed );
+        } else if (type == CSSPrimitiveValue::CSS_PERCENTAGE)
+            lineHeight = Length( ( style->font().pixelSize() * int(primitiveValue->floatValue(CSSPrimitiveValue::CSS_PERCENTAGE)) ) / 100, Fixed );
+        else if (type == CSSPrimitiveValue::CSS_NUMBER)
+            lineHeight = Length(int(primitiveValue->floatValue(CSSPrimitiveValue::CSS_NUMBER)*100), Percent);
+        else
+            return;
+        style->setLineHeight(lineHeight);
+        return;
+    }
+
+// string
+    case CSS_PROP_TEXT_ALIGN:
+    {
+        HANDLE_INHERIT_AND_INITIAL(textAlign, TextAlign)
+        if (!primitiveValue) return;
+        if (primitiveValue->getIdent())
+            style->setTextAlign( (ETextAlign) (primitiveValue->getIdent() - CSS_VAL__KHTML_AUTO) );
+	return;
+    }
+
+// rect
+    case CSS_PROP_CLIP:
+    {
+        Length top = Length();
+        Length right = Length();
+        Length bottom = Length();
+        Length left = Length();
+
+        bool hasClip = false;
+
+        if (isInherit && parentStyle->hasClip()) {
+            hasClip = true;
+	    top = parentStyle->clipTop();
+	    right = parentStyle->clipRight();
+	    bottom = parentStyle->clipBottom();
+	    left = parentStyle->clipLeft();
+        } else if (primitiveValue && primitiveValue->primitiveType() == CSSPrimitiveValue::CSS_RECT) {
+            RectImpl *rect = primitiveValue->getRectValue();
+            if (rect) {
+                hasClip = true;
+                top = convertToLength( rect->top(), style, paintDeviceMetrics );
+                right = convertToLength( rect->right(), style, paintDeviceMetrics );
+                bottom = convertToLength( rect->bottom(), style, paintDeviceMetrics );
+                left = convertToLength( rect->left(), style, paintDeviceMetrics );
+            }
+        }
+
+        style->setClip(top, right, bottom, left);
+        style->setHasClip(hasClip);
+
+        // rect, ident
+        break;
+    }
+
+// lists
+    case CSS_PROP_CONTENT:
+        // list of string, uri, counter, attr, i
+    {
+        // FIXME: In CSS3, it will be possible to inherit content.  In CSS2 it is not.  This
+        // note is a reminder that eventually "inherit" needs to be supported.
+
+        // not allowed on non-generated pseudo-elements:
+        if ( style->styleType()==RenderStyle::FIRST_LETTER ||
+             style->styleType()==RenderStyle::FIRST_LINE ||
+             style->styleType()==RenderStyle::SELECTION )
+            break;
+
+        if (isInitial) {
+            style->setContentNormal();
+            return;
+        }
+
+        if (primitiveValue && primitiveValue->primitiveType() == CSSPrimitiveValue::CSS_IDENT) {
+            // normal | none
+            if (primitiveValue->getIdent() == CSS_VAL_NORMAL)
+                style->setContentNormal();
+            else
+            if (primitiveValue->getIdent() == CSS_VAL_NONE)
+                style->setContentNone();
+            else
+                assert(false);
+            return;
+        }
+
+        if(!value->isValueList()) return;
+        CSSValueListImpl *list = static_cast<CSSValueListImpl *>(value);
+        int len = list->length();
+
+        style->setContentNormal(); // clear the content
+
+        for(int i = 0; i < len; i++) {
+            CSSValueImpl *item = list->item(i);
+            if(!item->isPrimitiveValue()) continue;
+            CSSPrimitiveValueImpl *val = static_cast<CSSPrimitiveValueImpl *>(item);
+            if(val->primitiveType()==CSSPrimitiveValue::CSS_STRING)
+            {
+                style->addContent(val->getStringValue());
+            }
+            else if (val->primitiveType()==CSSPrimitiveValue::CSS_ATTR)
+            {
+                // TODO: setup dynamic attribute dependencies
+                int attrID = element->getDocument()->getId(NodeImpl::AttributeId, val->getStringValue(), false, true);
+                if (attrID)
+                    style->addContent(element->getAttribute(attrID).implementation());
+                else
+                    kdDebug(6080) << "Attribute \"" << val->getStringValue() << "\" not found" << endl;
+            }
+            else if (val->primitiveType()==CSSPrimitiveValue::CSS_URI)
+            {
+                CSSImageValueImpl *image = static_cast<CSSImageValueImpl *>(val);
+                style->addContent(image->image());
+            }
+            else if (val->primitiveType()==CSSPrimitiveValue::CSS_COUNTER)
+            {
+                style->addContent(val->getCounterValue());
+            }
+            else if (val->primitiveType()==CSSPrimitiveValue::CSS_IDENT)
+            {
+                EQuoteContent quote;
+                switch (val->getIdent()) {
+                    case CSS_VAL_OPEN_QUOTE:
+                        quote = OPEN_QUOTE;
+                        break;
+                    case CSS_VAL_NO_OPEN_QUOTE:
+                        quote = NO_OPEN_QUOTE;
+                        break;
+                    case CSS_VAL_CLOSE_QUOTE:
+                        quote = CLOSE_QUOTE;
+                        break;
+                    case CSS_VAL_NO_CLOSE_QUOTE:
+                        quote = NO_CLOSE_QUOTE;
+                        break;
+                    default:
+                        assert(false);
+                }
+                style->addContent(quote);
+            } else
+                kdDebug(6080) << "Unrecognized CSS content" << endl;
+
+        }
+        break;
+    }
+
+    case CSS_PROP_COUNTER_INCREMENT: {
+        if(!value->isValueList()) return;
+
+        CSSValueListImpl *list = static_cast<CSSValueListImpl *>(value);
+        style->setCounterIncrement(list);
+        break;
+    }
+    case CSS_PROP_COUNTER_RESET: {
+        if(!value->isValueList()) return;
+
+        CSSValueListImpl *list = static_cast<CSSValueListImpl *>(value);
+        style->setCounterReset(list);
+        break;
+    }
+    case CSS_PROP_FONT_FAMILY:
+        // list of strings and ids
+    {
+        if (isInherit) {
+            FontDef parentFontDef = parentStyle->htmlFont().fontDef;
+            FontDef fontDef = style->htmlFont().fontDef;
+            fontDef.family = parentFontDef.family;
+            if (style->setFontDef(fontDef))
+                fontDirty = true;
+            return;
+        }
+        else if (isInitial) {
+            FontDef fontDef = style->htmlFont().fontDef;
+            FontDef initialDef = FontDef();
+#ifdef APPLE_CHANGES
+            fontDef.family = initialDef.firstFamily();
+#else
+            fontDef.family = TQString::null;
+#endif
+            if (style->setFontDef(fontDef))
+                fontDirty = true;
+            return;
+        }
+        if(!value->isValueList()) return;
+	FontDef fontDef = style->htmlFont().fontDef;
+        CSSValueListImpl *list = static_cast<CSSValueListImpl *>(value);
+        int len = list->length();
+        for(int i = 0; i < len; i++) {
+            CSSValueImpl *item = list->item(i);
+            if(!item->isPrimitiveValue()) continue;
+            CSSPrimitiveValueImpl *val = static_cast<CSSPrimitiveValueImpl *>(item);
+	    TQString face;
+            if( val->primitiveType() == CSSPrimitiveValue::CSS_STRING )
+		face = static_cast<FontFamilyValueImpl *>(val)->fontName();
+	    else if ( val->primitiveType() == CSSPrimitiveValue::CSS_IDENT ) {
+		switch( val->getIdent() ) {
+		case CSS_VAL_SERIF:
+		    face = settings->serifFontName();
+		    break;
+		case CSS_VAL_SANS_SERIF:
+		    face = settings->sansSerifFontName();
+		    break;
+		case CSS_VAL_CURSIVE:
+		    face = settings->cursiveFontName();
+		    break;
+		case CSS_VAL_FANTASY:
+		    face = settings->fantasyFontName();
+		    break;
+		case CSS_VAL_MONOSPACE:
+		    face = settings->fixedFontName();
+		    break;
+		default:
+		    return;
+		}
+	    } else {
+		return;
+	    }
+	    if ( !face.isEmpty() ) {
+		fontDef.family = face;
+		fontDirty |= style->setFontDef( fontDef );
+                return;
+	    }
+	}
+        break;
+    }
+    case CSS_PROP_QUOTES:
+        HANDLE_INHERIT_AND_INITIAL(quotes, Quotes)
+        if(primitiveValue && primitiveValue->getIdent() == CSS_VAL_NONE) {
+            // set a set of empty quotes
+            QuotesValueImpl* quotes = new QuotesValueImpl();
+            style->setQuotes(quotes);
+        } else {
+            QuotesValueImpl* quotes = static_cast<QuotesValueImpl *>(value);
+            style->setQuotes(quotes);
+        }
+        break;
+    case CSS_PROP_SIZE:
+        // ### look up
+      break;
+    case CSS_PROP_TEXT_DECORATION: {
+        // list of ident
+        HANDLE_INHERIT_AND_INITIAL(textDecoration, TextDecoration)
+        int t = RenderStyle::initialTextDecoration();
+        if(primitiveValue && primitiveValue->getIdent() == CSS_VAL_NONE) {
+	    // do nothing
+	} else {
+	    if(!value->isValueList()) return;
+	    CSSValueListImpl *list = static_cast<CSSValueListImpl *>(value);
+	    int len = list->length();
+	    for(int i = 0; i < len; i++)
+	    {
+		CSSValueImpl *item = list->item(i);
+		if(!item->isPrimitiveValue()) continue;
+		primitiveValue = static_cast<CSSPrimitiveValueImpl *>(item);
+		switch(primitiveValue->getIdent())
+		{
+		    case CSS_VAL_NONE:
+			t = TDNONE; break;
+		    case CSS_VAL_UNDERLINE:
+			t |= UNDERLINE; break;
+		    case CSS_VAL_OVERLINE:
+			t |= OVERLINE; break;
+		    case CSS_VAL_LINE_THROUGH:
+			t |= LINE_THROUGH; break;
+		    case CSS_VAL_BLINK:
+			t |= BLINK; break;
+		    default:
+			return;
+		}
+	    }
+        }
+	style->setTextDecoration(t);
+        break;
+    }
+    case CSS_PROP__KHTML_FLOW_MODE:
+        HANDLE_INHERIT_AND_INITIAL(flowAroundFloats, FlowAroundFloats)
+        if (!primitiveValue) return;
+        if (primitiveValue->getIdent()) {
+            style->setFlowAroundFloats( primitiveValue->getIdent() == CSS_VAL__KHTML_AROUND_FLOATS );
+            return;
+        }
+        break;
+    case CSS_PROP__KHTML_USER_INPUT: {
+        if(value->cssValueType() == CSSValue::CSS_INHERIT)
+        {
+            if(!parentNode) return;
+            style->setUserInput(parentStyle->userInput());
+//	    kdDebug() << "UI erm" << endl;
+            return;
+        }
+        if(!primitiveValue) return;
+        int id = primitiveValue->getIdent();
+	if (id == CSS_VAL_NONE)
+	    style->setUserInput(UI_NONE);
+	else
+	    style->setUserInput(EUserInput(id - CSS_VAL_ENABLED));
+//	kdDebug(6080) << "userInput: " << style->userEdit() << endl;
+	return;
+    }
+
+// shorthand properties
+    case CSS_PROP_BACKGROUND:
+        if (isInitial) {
+            style->clearBackgroundLayers();
+            return;
+        }
+        else if (isInherit) {
+            if (parentStyle)
+                style->inheritBackgroundLayers(*parentStyle->backgroundLayers());
+            else
+                style->clearBackgroundLayers();
+            return;
+        }
+        break;
+    case CSS_PROP_BORDER:
+    case CSS_PROP_BORDER_STYLE:
+    case CSS_PROP_BORDER_WIDTH:
+    case CSS_PROP_BORDER_COLOR:
+        if(id == CSS_PROP_BORDER || id == CSS_PROP_BORDER_COLOR)
+        {
+             if (isInherit) {
+                style->setBorderTopColor(parentStyle->borderTopColor());
+                style->setBorderBottomColor(parentStyle->borderBottomColor());
+                style->setBorderLeftColor(parentStyle->borderLeftColor());
+                style->setBorderRightColor(parentStyle->borderRightColor());
+            }
+            else if (isInitial) {
+                style->setBorderTopColor(TQColor()); // Reset to invalid color so currentColor is used instead.
+                style->setBorderBottomColor(TQColor());
+                style->setBorderLeftColor(TQColor());
+                style->setBorderRightColor(TQColor());
+            }
+        }
+        if (id == CSS_PROP_BORDER || id == CSS_PROP_BORDER_STYLE)
+        {
+            if (isInherit) {
+                style->setBorderTopStyle(parentStyle->borderTopStyle());
+                style->setBorderBottomStyle(parentStyle->borderBottomStyle());
+                style->setBorderLeftStyle(parentStyle->borderLeftStyle());
+                style->setBorderRightStyle(parentStyle->borderRightStyle());
+            }
+            else if (isInitial) {
+                style->setBorderTopStyle(RenderStyle::initialBorderStyle());
+                style->setBorderBottomStyle(RenderStyle::initialBorderStyle());
+                style->setBorderLeftStyle(RenderStyle::initialBorderStyle());
+                style->setBorderRightStyle(RenderStyle::initialBorderStyle());
+            }
+        }
+        if (id == CSS_PROP_BORDER || id == CSS_PROP_BORDER_WIDTH)
+        {
+            if (isInherit) {
+                style->setBorderTopWidth(parentStyle->borderTopWidth());
+                style->setBorderBottomWidth(parentStyle->borderBottomWidth());
+                style->setBorderLeftWidth(parentStyle->borderLeftWidth());
+                style->setBorderRightWidth(parentStyle->borderRightWidth());
+            }
+            else if (isInitial) {
+                style->setBorderTopWidth(RenderStyle::initialBorderWidth());
+                style->setBorderBottomWidth(RenderStyle::initialBorderWidth());
+                style->setBorderLeftWidth(RenderStyle::initialBorderWidth());
+                style->setBorderRightWidth(RenderStyle::initialBorderWidth());
+            }
+        }
+        return;
+    case CSS_PROP_BORDER_TOP:
+        if ( isInherit ) {
+            style->setBorderTopColor(parentStyle->borderTopColor());
+            style->setBorderTopStyle(parentStyle->borderTopStyle());
+            style->setBorderTopWidth(parentStyle->borderTopWidth());
+        } else if (isInitial)
+            style->resetBorderTop();
+        return;
+    case CSS_PROP_BORDER_RIGHT:
+        if (isInherit) {
+            style->setBorderRightColor(parentStyle->borderRightColor());
+            style->setBorderRightStyle(parentStyle->borderRightStyle());
+            style->setBorderRightWidth(parentStyle->borderRightWidth());
+        }
+        else if (isInitial)
+            style->resetBorderRight();
+        return;
+    case CSS_PROP_BORDER_BOTTOM:
+        if (isInherit) {
+            style->setBorderBottomColor(parentStyle->borderBottomColor());
+            style->setBorderBottomStyle(parentStyle->borderBottomStyle());
+            style->setBorderBottomWidth(parentStyle->borderBottomWidth());
+        }
+        else if (isInitial)
+            style->resetBorderBottom();
+        return;
+    case CSS_PROP_BORDER_LEFT:
+        if (isInherit) {
+            style->setBorderLeftColor(parentStyle->borderLeftColor());
+            style->setBorderLeftStyle(parentStyle->borderLeftStyle());
+            style->setBorderLeftWidth(parentStyle->borderLeftWidth());
+        }
+        else if (isInitial)
+            style->resetBorderLeft();
+        return;
+    case CSS_PROP_MARGIN:
+        if (isInherit) {
+            style->setMarginTop(parentStyle->marginTop());
+            style->setMarginBottom(parentStyle->marginBottom());
+            style->setMarginLeft(parentStyle->marginLeft());
+            style->setMarginRight(parentStyle->marginRight());
+        }
+        else if (isInitial)
+            style->resetMargin();
+        return;
+    case CSS_PROP_PADDING:
+        if (isInherit) {
+            style->setPaddingTop(parentStyle->paddingTop());
+            style->setPaddingBottom(parentStyle->paddingBottom());
+            style->setPaddingLeft(parentStyle->paddingLeft());
+            style->setPaddingRight(parentStyle->paddingRight());
+        }
+        else if (isInitial)
+            style->resetPadding();
+        return;
+    case CSS_PROP_FONT:
+        if ( isInherit ) {
+            FontDef fontDef = parentStyle->htmlFont().fontDef;
+	    style->setLineHeight( parentStyle->lineHeight() );
+	    fontDirty |= style->setFontDef( fontDef );
+        } else if (isInitial) {
+            FontDef fontDef;
+            style->setLineHeight(RenderStyle::initialLineHeight());
+            if (style->setFontDef( fontDef ))
+                fontDirty = true;
+	} else if ( value->isFontValue() ) {
+	    FontValueImpl *font = static_cast<FontValueImpl *>(value);
+	    if ( !font->style || !font->variant || !font->weight ||
+		 !font->size || !font->lineHeight || !font->family )
+		return;
+	    applyRule( CSS_PROP_FONT_STYLE, font->style );
+	    applyRule( CSS_PROP_FONT_VARIANT, font->variant );
+	    applyRule( CSS_PROP_FONT_WEIGHT, font->weight );
+	    applyRule( CSS_PROP_FONT_SIZE, font->size );
+
+            // Line-height can depend on font().pixelSize(), so we have to update the font
+            // before we evaluate line-height, e.g., font: 1em/1em.  FIXME: Still not
+            // good enough: style="font:1em/1em; font-size:36px" should have a line-height of 36px.
+            if (fontDirty)
+                CSSStyleSelector::style->htmlFont().update( paintDeviceMetrics );
+
+	    applyRule( CSS_PROP_LINE_HEIGHT, font->lineHeight );
+	    applyRule( CSS_PROP_FONT_FAMILY, font->family );
+	}
+	return;
+
+    case CSS_PROP_LIST_STYLE:
+        if (isInherit) {
+            style->setListStyleType(parentStyle->listStyleType());
+            style->setListStyleImage(parentStyle->listStyleImage());
+            style->setListStylePosition(parentStyle->listStylePosition());
+        }
+        else if (isInitial) {
+            style->setListStyleType(RenderStyle::initialListStyleType());
+            style->setListStyleImage(RenderStyle::initialListStyleImage());
+            style->setListStylePosition(RenderStyle::initialListStylePosition());
+        }
+        break;
+    case CSS_PROP_OUTLINE:
+        if (isInherit) {
+            style->setOutlineWidth(parentStyle->outlineWidth());
+            style->setOutlineColor(parentStyle->outlineColor());
+            style->setOutlineStyle(parentStyle->outlineStyle());
+        }
+        else if (isInitial)
+            style->resetOutline();
+        break;
+    /* CSS3 properties */
+    case CSS_PROP_BOX_SIZING:
+        HANDLE_INHERIT(boxSizing, BoxSizing)
+        if (!primitiveValue) return;
+        if (primitiveValue->getIdent() == CSS_VAL_CONTENT_BOX)
+            style->setBoxSizing(CONTENT_BOX);
+        else
+        if (primitiveValue->getIdent() == CSS_VAL_BORDER_BOX)
+            style->setBoxSizing(BORDER_BOX);
+        break;
+    case CSS_PROP_OUTLINE_OFFSET: {
+        HANDLE_INHERIT_AND_INITIAL(outlineOffset, OutlineOffset)
+
+        int offset = primitiveValue->computeLength(style, paintDeviceMetrics);
+        if (offset < 0) return;
+
+        style->setOutlineOffset(offset);
+        break;
+    }
+    case CSS_PROP_TEXT_SHADOW: {
+        if (isInherit) {
+            style->setTextShadow(parentStyle->textShadow() ? new ShadowData(*parentStyle->textShadow()) : 0);
+            return;
+        }
+        else if (isInitial) {
+            style->setTextShadow(0);
+            return;
+        }
+
+        if (primitiveValue) { // none
+            style->setTextShadow(0);
+            return;
+        }
+
+        if (!value->isValueList()) return;
+        CSSValueListImpl *list = static_cast<CSSValueListImpl *>(value);
+        int len = list->length();
+        for (int i = 0; i < len; i++) {
+            ShadowValueImpl *item = static_cast<ShadowValueImpl*>(list->item(i));
+
+            int x = item->x->computeLength(style, paintDeviceMetrics);
+            int y = item->y->computeLength(style, paintDeviceMetrics);
+            int blur = item->blur ? item->blur->computeLength(style, paintDeviceMetrics) : 0;
+            TQColor col = tdehtml::transparentColor;
+            if (item->color) {
+                int ident = item->color->getIdent();
+                if (ident)
+                    col = colorForCSSValue( ident );
+                else if (item->color->primitiveType() == CSSPrimitiveValue::CSS_RGBCOLOR)
+                    col.setRgb(item->color->getRGBColorValue());
+            }
+            ShadowData* shadowData = new ShadowData(x, y, blur, col);
+            style->setTextShadow(shadowData, i != 0);
+        }
+
+        break;
+    }
+    case CSS_PROP_OPACITY:
+        HANDLE_INHERIT_AND_INITIAL(opacity, Opacity)
+        if (!primitiveValue || primitiveValue->primitiveType() != CSSPrimitiveValue::CSS_NUMBER)
+            return; // Error case.
+
+        // Clamp opacity to the range 0-1
+        style->setOpacity(kMin(1.0f, kMax(0.0f, (float)primitiveValue->floatValue(CSSPrimitiveValue::CSS_NUMBER))));
+        break;
+    case CSS_PROP__KHTML_MARQUEE:
+        if (value->cssValueType() != CSSValue::CSS_INHERIT || !parentNode) return;
+        style->setMarqueeDirection(parentStyle->marqueeDirection());
+        style->setMarqueeIncrement(parentStyle->marqueeIncrement());
+        style->setMarqueeSpeed(parentStyle->marqueeSpeed());
+        style->setMarqueeLoopCount(parentStyle->marqueeLoopCount());
+        style->setMarqueeBehavior(parentStyle->marqueeBehavior());
+        break;
+    case CSS_PROP__KHTML_MARQUEE_REPETITION: {
+        HANDLE_INHERIT_AND_INITIAL(marqueeLoopCount, MarqueeLoopCount)
+        if (!primitiveValue) return;
+        if (primitiveValue->getIdent() == CSS_VAL_INFINITE)
+            style->setMarqueeLoopCount(-1); // -1 means repeat forever.
+        else if (primitiveValue->primitiveType() == CSSPrimitiveValue::CSS_NUMBER)
+            style->setMarqueeLoopCount((int)(primitiveValue->floatValue(CSSPrimitiveValue::CSS_NUMBER)));
+        break;
+    }
+    case CSS_PROP__KHTML_MARQUEE_SPEED: {
+        HANDLE_INHERIT_AND_INITIAL(marqueeSpeed, MarqueeSpeed)
+        if (!primitiveValue) return;
+        if (primitiveValue->getIdent()) {
+            switch (primitiveValue->getIdent())
+            {
+                case CSS_VAL_SLOW:
+                    style->setMarqueeSpeed(500); // 500 msec.
+                    break;
+                case CSS_VAL_NORMAL:
+                    style->setMarqueeSpeed(85); // 85msec. The WinIE default.
+                    break;
+                case CSS_VAL_FAST:
+                    style->setMarqueeSpeed(10); // 10msec. Super fast.
+                    break;
+            }
+        }
+        else if (primitiveValue->primitiveType() == CSSPrimitiveValue::CSS_S)
+            style->setMarqueeSpeed(int(1000*primitiveValue->floatValue(CSSPrimitiveValue::CSS_S)));
+        else if (primitiveValue->primitiveType() == CSSPrimitiveValue::CSS_MS)
+            style->setMarqueeSpeed(int(primitiveValue->floatValue(CSSPrimitiveValue::CSS_MS)));
+        else if (primitiveValue->primitiveType() == CSSPrimitiveValue::CSS_NUMBER) // For scrollamount support.
+            style->setMarqueeSpeed(int(primitiveValue->floatValue(CSSPrimitiveValue::CSS_NUMBER)));
+        break;
+    }
+    case CSS_PROP__KHTML_MARQUEE_INCREMENT: {
+        HANDLE_INHERIT_AND_INITIAL(marqueeIncrement, MarqueeIncrement)
+        if (!primitiveValue) return;
+        if (primitiveValue->getIdent()) {
+            switch (primitiveValue->getIdent())
+            {
+                case CSS_VAL_SMALL:
+                    style->setMarqueeIncrement(Length(1, Fixed)); // 1px.
+                    break;
+                case CSS_VAL_NORMAL:
+                    style->setMarqueeIncrement(Length(6, Fixed)); // 6px. The WinIE default.
+                    break;
+                case CSS_VAL_LARGE:
+                    style->setMarqueeIncrement(Length(36, Fixed)); // 36px.
+                    break;
+            }
+        }
+        else {
+            bool ok = true;
+            Length l = convertToLength(primitiveValue, style, paintDeviceMetrics, &ok);
+            if (ok)
+                style->setMarqueeIncrement(l);
+        }
+        break;
+    }
+    case CSS_PROP__KHTML_MARQUEE_STYLE: {
+        HANDLE_INHERIT_AND_INITIAL(marqueeBehavior, MarqueeBehavior)
+        if (!primitiveValue || !primitiveValue->getIdent()) return;
+        switch (primitiveValue->getIdent())
+        {
+            case CSS_VAL_NONE:
+                style->setMarqueeBehavior(MNONE);
+                break;
+            case CSS_VAL_SCROLL:
+                style->setMarqueeBehavior(MSCROLL);
+                break;
+            case CSS_VAL_SLIDE:
+                style->setMarqueeBehavior(MSLIDE);
+                break;
+            case CSS_VAL_ALTERNATE:
+                style->setMarqueeBehavior(MALTERNATE);
+                break;
+            case CSS_VAL_UNFURL:
+                style->setMarqueeBehavior(MUNFURL);
+                break;
+        }
+        break;
+    }
+    case CSS_PROP__KHTML_MARQUEE_DIRECTION: {
+        HANDLE_INHERIT_AND_INITIAL(marqueeDirection, MarqueeDirection)
+        if (!primitiveValue || !primitiveValue->getIdent()) return;
+        switch (primitiveValue->getIdent())
+        {
+            case CSS_VAL_FORWARDS:
+                style->setMarqueeDirection(MFORWARD);
+                break;
+            case CSS_VAL_BACKWARDS:
+                style->setMarqueeDirection(MBACKWARD);
+                break;
+            case CSS_VAL_AUTO:
+                style->setMarqueeDirection(MAUTO);
+                break;
+            case CSS_VAL_AHEAD:
+            case CSS_VAL_UP: // We don't support vertical languages, so AHEAD just maps to UP.
+                style->setMarqueeDirection(MUP);
+                break;
+            case CSS_VAL_REVERSE:
+            case CSS_VAL_DOWN: // REVERSE just maps to DOWN, since we don't do vertical text.
+                style->setMarqueeDirection(MDOWN);
+                break;
+            case CSS_VAL_LEFT:
+                style->setMarqueeDirection(MLEFT);
+                break;
+            case CSS_VAL_RIGHT:
+                style->setMarqueeDirection(MRIGHT);
+                break;
+        }
+        break;
+    case CSS_PROP_TEXT_OVERFLOW: {
+        // This property is supported by WinIE, and so we leave off the "-tdehtml-" in order to
+        // work with WinIE-specific pages that use the property.
+        HANDLE_INHERIT_AND_INITIAL(textOverflow, TextOverflow)
+        if (!primitiveValue || !primitiveValue->getIdent())
+            return;
+        style->setTextOverflow(primitiveValue->getIdent() == CSS_VAL_ELLIPSIS);
+        break;
+    }
+    }
+    case CSS_PROP_WORD_WRAP: {
+        HANDLE_INITIAL_AND_INHERIT_ON_INHERITED_PROPERTY(wordWrap, WordWrap)
+        if (!primitiveValue)
+            return;
+        style->setWordWrap(primitiveValue->getIdent() == CSS_VAL_NORMAL ? WWNORMAL : WWBREAKWORD);
+        break;
+    }
+    default:
+        return;
+    }
+}
+
+void CSSStyleSelector::mapBackgroundAttachment(BackgroundLayer* layer, DOM::CSSValueImpl* value)
+{
+    if (value->cssValueType() == CSSValue::CSS_INITIAL) {
+        layer->setBackgroundAttachment(RenderStyle::initialBackgroundAttachment());
+        return;
+    }
+
+    if (!value->isPrimitiveValue()) return;
+    CSSPrimitiveValueImpl* primitiveValue = static_cast<CSSPrimitiveValueImpl*>(value);
+    switch (primitiveValue->getIdent()) {
+        case CSS_VAL_FIXED:
+            layer->setBackgroundAttachment(false);
+            break;
+        case CSS_VAL_SCROLL:
+            layer->setBackgroundAttachment(true);
+            break;
+        default:
+            return;
+    }
+}
+
+void CSSStyleSelector::mapBackgroundClip(BackgroundLayer* layer, CSSValueImpl* value)
+{
+    if (value->cssValueType() == CSSValue::CSS_INITIAL) {
+        layer->setBackgroundClip(RenderStyle::initialBackgroundClip());
+        return;
+    }
+
+    if (!value->isPrimitiveValue()) return;
+    CSSPrimitiveValueImpl* primitiveValue = static_cast<CSSPrimitiveValueImpl*>(value);
+    switch (primitiveValue->getIdent()) {
+        case CSS_VAL_BORDER:
+            layer->setBackgroundClip(BGBORDER);
+            break;
+        case CSS_VAL_PADDING:
+            layer->setBackgroundClip(BGPADDING);
+            break;
+        default: // CSS_VAL_CONTENT
+            layer->setBackgroundClip(BGCONTENT);
+            break;
+    }
+}
+
+void CSSStyleSelector::mapBackgroundOrigin(BackgroundLayer* layer, CSSValueImpl* value)
+{
+    if (value->cssValueType() == CSSValue::CSS_INITIAL) {
+        layer->setBackgroundOrigin(RenderStyle::initialBackgroundOrigin());
+        return;
+    }
+
+    if (!value->isPrimitiveValue()) return;
+    CSSPrimitiveValueImpl* primitiveValue = static_cast<CSSPrimitiveValueImpl*>(value);
+    switch (primitiveValue->getIdent()) {
+        case CSS_VAL_BORDER:
+            layer->setBackgroundOrigin(BGBORDER);
+            break;
+        case CSS_VAL_PADDING:
+            layer->setBackgroundOrigin(BGPADDING);
+            break;
+        default: // CSS_VAL_CONTENT
+            layer->setBackgroundOrigin(BGCONTENT);
+            break;
+    }
+}
+
+void CSSStyleSelector::mapBackgroundImage(BackgroundLayer* layer, DOM::CSSValueImpl* value)
+{
+    if (value->cssValueType() == CSSValue::CSS_INITIAL) {
+        layer->setBackgroundImage(RenderStyle::initialBackgroundImage());
+        return;
+    }
+
+    if (!value->isPrimitiveValue()) return;
+    CSSPrimitiveValueImpl* primitiveValue = static_cast<CSSPrimitiveValueImpl*>(value);
+    layer->setBackgroundImage(static_cast<CSSImageValueImpl *>(primitiveValue)->image());
+}
+
+void CSSStyleSelector::mapBackgroundRepeat(BackgroundLayer* layer, DOM::CSSValueImpl* value)
+{
+    if (value->cssValueType() == CSSValue::CSS_INITIAL) {
+        layer->setBackgroundRepeat(RenderStyle::initialBackgroundRepeat());
+        return;
+    }
+
+    if (!value->isPrimitiveValue()) return;
+    CSSPrimitiveValueImpl* primitiveValue = static_cast<CSSPrimitiveValueImpl*>(value);
+    switch(primitiveValue->getIdent()) {
+	case CSS_VAL_REPEAT:
+	    layer->setBackgroundRepeat(REPEAT);
+	    break;
+	case CSS_VAL_REPEAT_X:
+	    layer->setBackgroundRepeat(REPEAT_X);
+	    break;
+	case CSS_VAL_REPEAT_Y:
+	    layer->setBackgroundRepeat(REPEAT_Y);
+	    break;
+	case CSS_VAL_NO_REPEAT:
+	    layer->setBackgroundRepeat(NO_REPEAT);
+	    break;
+	default:
+	    return;
+    }
+}
+
+
+void CSSStyleSelector::mapBackgroundSize(BackgroundLayer* layer, CSSValueImpl* value)
+{
+    LengthSize b = RenderStyle::initialBackgroundSize();
+
+    if (value->cssValueType() == CSSValue::CSS_INITIAL) {
+        layer->setBackgroundSize(b);
+        return;
+    }
+
+    if (!value->isPrimitiveValue())
+        return;
+
+    CSSPrimitiveValueImpl* primitiveValue = static_cast<CSSPrimitiveValueImpl*>(value);
+    PairImpl* pair = primitiveValue->getPairValue();
+    if (!pair)
+        return;
+
+    CSSPrimitiveValueImpl* first = static_cast<CSSPrimitiveValueImpl*>(pair->first());
+    CSSPrimitiveValueImpl* second = static_cast<CSSPrimitiveValueImpl*>(pair->second());
+
+    if (!first || !second)
+        return;
+
+    Length firstLength, secondLength;
+    int firstType = first->primitiveType();
+    int secondType = second->primitiveType();
+
+    if (firstType == CSSPrimitiveValue::CSS_UNKNOWN)
+        firstLength = Length(Variable);
+    else if (firstType > CSSPrimitiveValue::CSS_PERCENTAGE && firstType < CSSPrimitiveValue::CSS_DEG)
+        firstLength = Length(first->computeLength(style, paintDeviceMetrics), Fixed);
+    else if (firstType == CSSPrimitiveValue::CSS_PERCENTAGE)
+        firstLength = Length((int)first->floatValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);
+    else
+        return;
+
+    if (secondType == CSSPrimitiveValue::CSS_UNKNOWN)
+        secondLength = Length(Variable);
+    else if (secondType > CSSPrimitiveValue::CSS_PERCENTAGE && secondType < CSSPrimitiveValue::CSS_DEG)
+        secondLength = Length(second->computeLength(style, paintDeviceMetrics), Fixed);
+    else if (secondType == CSSPrimitiveValue::CSS_PERCENTAGE)
+        secondLength = Length((int)second->floatValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);
+    else
+        return;
+
+    b.width = firstLength;
+    b.height = secondLength;
+    layer->setBackgroundSize(b);
+}
+
+void CSSStyleSelector::mapBackgroundXPosition(BackgroundLayer* layer, DOM::CSSValueImpl* value)
+{
+    if (value->cssValueType() == CSSValue::CSS_INITIAL) {
+        layer->setBackgroundXPosition(RenderStyle::initialBackgroundXPosition());
+        return;
+    }
+
+    if (!value->isPrimitiveValue()) return;
+    CSSPrimitiveValueImpl* primitiveValue = static_cast<CSSPrimitiveValueImpl*>(value);
+    Length l;
+    int type = primitiveValue->primitiveType();
+    if(type > CSSPrimitiveValue::CSS_PERCENTAGE && type < CSSPrimitiveValue::CSS_DEG)
+        l = Length(primitiveValue->computeLength(style, paintDeviceMetrics), Fixed);
+    else if(type == CSSPrimitiveValue::CSS_PERCENTAGE)
+        l = Length((int)primitiveValue->floatValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);
+    else
+        return;
+    layer->setBackgroundXPosition(l);
+}
+
+void CSSStyleSelector::mapBackgroundYPosition(BackgroundLayer* layer, DOM::CSSValueImpl* value)
+{
+    if (value->cssValueType() == CSSValue::CSS_INITIAL) {
+        layer->setBackgroundYPosition(RenderStyle::initialBackgroundYPosition());
+        return;
+    }
+
+    if (!value->isPrimitiveValue()) return;
+    CSSPrimitiveValueImpl* primitiveValue = static_cast<CSSPrimitiveValueImpl*>(value);
+    Length l;
+    int type = primitiveValue->primitiveType();
+    if(type > CSSPrimitiveValue::CSS_PERCENTAGE && type < CSSPrimitiveValue::CSS_DEG)
+        l = Length(primitiveValue->computeLength(style, paintDeviceMetrics), Fixed);
+    else if(type == CSSPrimitiveValue::CSS_PERCENTAGE)
+        l = Length((int)primitiveValue->floatValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);
+    else
+        return;
+    layer->setBackgroundYPosition(l);
+}
+
+#ifdef APPLE_CHANGES
+void CSSStyleSelector::checkForGenericFamilyChange(RenderStyle* aStyle, RenderStyle* aParentStyle)
+{
+  const FontDef& childFont = aStyle->htmlFont().fontDef;
+
+  if (childFont.sizeSpecified || !aParentStyle)
+    return;
+
+  const FontDef& parentFont = aParentStyle->htmlFont().fontDef;
+
+  if (childFont.genericFamily == parentFont.genericFamily)
+    return;
+
+  // For now, lump all families but monospace together.
+  if (childFont.genericFamily != FontDef::eMonospace &&
+      parentFont.genericFamily != FontDef::eMonospace)
+    return;
+
+  // We know the parent is monospace or the child is monospace, and that font
+  // size was unspecified.  We want to alter our font size to use the correct
+  // "medium" font for our family.
+  float size = 0;
+  int minFontSize = settings->minFontSize();
+  size = (childFont.genericFamily == FontDef::eMonospace) ? m_fixedFontSizes[3] : m_fontSizes[3];
+  int isize = (int)size;
+  if (isize < minFontSize)
+    isize = minFontSize;
+
+  FontDef newFontDef(childFont);
+  newFontDef.size = isize;
+  aStyle->setFontDef(newFontDef);
+}
+#endif
+
+} // namespace tdehtml
diff --git a/tdehtml/css/cssstyleselector.h b/tdehtml/css/cssstyleselector.h
new file mode 100644
index 000000000..ad6903de7
--- /dev/null
+++ b/tdehtml/css/cssstyleselector.h
@@ -0,0 +1,333 @@
+/*
+ * This file is part of the CSS implementation for KDE.
+ *
+ * Copyright (C) 1999-2003 Lars Knoll (knoll@kde.org)
+ * Copyright (C) 2003, 2005, 2006 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 _CSS_cssstyleselector_h_
+#define _CSS_cssstyleselector_h_
+
+#include <tqptrlist.h>
+#include <tqvaluevector.h>
+
+#include "rendering/render_style.h"
+#include "dom/dom_string.h"
+#include "xml/dom_restyler.h"
+
+class KHTMLSettings;
+class KHTMLView;
+class KHTMLPart;
+class KHTMLFactory;
+class KURL;
+
+namespace DOM {
+    class DocumentImpl;
+    class NodeImpl;
+    class ElementImpl;
+    class StyleSheetImpl;
+    class CSSStyleRuleImpl;
+    class CSSStyleSheetImpl;
+    class CSSSelector;
+    class CSSStyleDeclarationImpl;
+    class CSSProperty;
+    class StyleSheetListImpl;
+    class CSSValueImpl;
+}
+
+namespace tdehtml
+{
+    class CSSStyleSelectorList;
+    class CSSOrderedRule;
+    class CSSOrderedProperty;
+    class CSSOrderedPropertyList;
+    class RenderStyle;
+
+    /*
+     * to remember the source where a rule came from. Differentiates between
+     * important and not important rules. This is ordered in the order they have to be applied
+     * to the RenderStyle.
+     */
+    enum Source {
+	Default = 0,
+	NonCSSHint = 1,
+	User = 2,
+	Author = 3,
+	Inline = 4,
+	AuthorImportant = 5,
+	InlineImportant = 6,
+	UserImportant =7
+    };
+
+    /**
+     * this class selects a RenderStyle for a given Element based on the
+     * collection of stylesheets it contains. This is just a virtual base class
+     * for specific implementations of the Selector. At the moment only CSSStyleSelector
+     * exists, but someone may wish to implement XSL...
+     */
+    class StyleSelector
+    {
+    public:
+	StyleSelector() {}
+
+	/* as nobody has implemented a second style selector up to now comment out
+	   the virtual methods until then, so the class has no vptr.
+	*/
+// 	virtual ~StyleSelector() {}
+// 	virtual RenderStyle *styleForElement(DOM::ElementImpl *e) = 0;
+
+	enum State {
+	    None = 0x00,
+	    Hover = 0x01,
+	    Focus = 0x02,
+	    Active = 0x04
+	};
+    };
+
+
+    /**
+     * the StyleSelector implementation for CSS.
+     */
+    class CSSStyleSelector : public StyleSelector
+    {
+    public:
+	/**
+	 * creates a new StyleSelector for a Document.
+	 * goes through all StyleSheets defined in the document and
+	 * creates a list of rules it needs to apply to objects
+	 *
+	 * Also takes into account special cases for HTML documents,
+	 * including the defaultStyle (which is html only)
+	 */
+	CSSStyleSelector( DOM::DocumentImpl* doc, TQString userStyleSheet, DOM::StyleSheetListImpl *styleSheets, const KURL &url,
+                          bool _strictParsing );
+	/**
+	 * same as above but for a single stylesheet.
+	 */
+	CSSStyleSelector( DOM::CSSStyleSheetImpl *sheet );
+
+	~CSSStyleSelector();
+
+	void addSheet( DOM::CSSStyleSheetImpl *sheet );
+        KDE_EXPORT static void clear();
+        static void reparseConfiguration();
+
+	static void loadDefaultStyle(const KHTMLSettings *s, DOM::DocumentImpl *doc);
+
+	RenderStyle *styleForElement(DOM::ElementImpl *e);
+
+        TQValueVector<int> fontSizes() const { return m_fontSizes; }
+	TQValueVector<int> fixedFontSizes() const { return m_fixedFontSizes; }
+
+	bool strictParsing;
+	struct Encodedurl {
+	    TQString host; //also contains protocol
+	    TQString path;
+	    TQString file;
+	} encodedurl;
+
+        void computeFontSizes(TQPaintDeviceMetrics* paintDeviceMetrics, int zoomFactor);
+	void computeFontSizesFor(TQPaintDeviceMetrics* paintDeviceMetrics, int zoomFactor, TQValueVector<int>& fontSizes, bool isFixed);
+
+	static void precomputeAttributeDependencies(DOM::DocumentImpl* doc, DOM::CSSSelector* sel);
+    protected:
+	/* checks if the complete selector (which can be build up from a few CSSSelector's
+	    with given relationships matches the given Element */
+	void checkSelector(int selector, DOM::ElementImpl *e);
+	/* checks if the selector matches the given Element */
+	bool checkSimpleSelector(DOM::CSSSelector *selector, DOM::ElementImpl *e, bool isAncestor, bool isSubSelector = false);
+
+        enum SelectorMatch {SelectorMatches = 0, SelectorFailsLocal, SelectorFails};
+        SelectorMatch checkSelector(DOM::CSSSelector *sel, DOM::ElementImpl *e, bool isAncestor, bool isSubSelector = false);
+
+        void addDependency(StructuralDependencyType dependencyType, DOM::ElementImpl* dependency);
+#ifdef APPLE_CHANGES
+	/* This function fixes up the default font size if it detects that the
+	   current generic font family has changed. -dwh */
+	void checkForGenericFamilyChange(RenderStyle* aStyle, RenderStyle* aParentStyle);
+#endif
+
+	/* builds up the selectors and properties lists from the CSSStyleSelectorList's */
+	void buildLists();
+	void clearLists();
+
+        void adjustRenderStyle(RenderStyle* style, DOM::ElementImpl *e);
+
+        unsigned int addInlineDeclarations(DOM::ElementImpl* e, DOM::CSSStyleDeclarationImpl *decl,
+				   unsigned int numProps);
+
+	static DOM::CSSStyleSheetImpl *s_defaultSheet;
+	static DOM::CSSStyleSheetImpl *s_quirksSheet;
+	static CSSStyleSelectorList *s_defaultStyle;
+	static CSSStyleSelectorList *s_defaultQuirksStyle;
+	static CSSStyleSelectorList *s_defaultPrintStyle;
+        static RenderStyle* styleNotYetAvailable;
+
+	CSSStyleSelectorList *defaultStyle;
+	CSSStyleSelectorList *defaultQuirksStyle;
+	CSSStyleSelectorList *defaultPrintStyle;
+
+	CSSStyleSelectorList *authorStyle;
+        CSSStyleSelectorList *userStyle;
+        DOM::CSSStyleSheetImpl *userSheet;
+
+public:
+
+    private:
+        void init(const KHTMLSettings* settings, DOM::DocumentImpl* doc);
+
+        void mapBackgroundAttachment(BackgroundLayer* layer, DOM::CSSValueImpl* value);
+        void mapBackgroundClip(BackgroundLayer* layer, DOM::CSSValueImpl* value);
+        void mapBackgroundOrigin(BackgroundLayer* layer, DOM::CSSValueImpl* value);
+        void mapBackgroundImage(BackgroundLayer* layer, DOM::CSSValueImpl* value);
+        void mapBackgroundRepeat(BackgroundLayer* layer, DOM::CSSValueImpl* value);
+        void mapBackgroundSize(BackgroundLayer* layer, DOM::CSSValueImpl* value);
+        void mapBackgroundXPosition(BackgroundLayer* layer, DOM::CSSValueImpl* value);
+        void mapBackgroundYPosition(BackgroundLayer* layer, DOM::CSSValueImpl* value);
+
+    public: // we need to make the enum public for SelectorCache
+	enum SelectorState {
+	    Unknown = 0,
+	    Applies,
+	    AppliesPseudo,
+	    Invalid
+	};
+
+        enum SelectorMedia {
+            MediaAural = 1,
+            MediaBraille,
+            MediaEmboss,
+            MediaHandheld,
+            MediaPrint,
+            MediaProjection,
+            MediaScreen,
+            MediaTTY,
+            MediaTV
+        };
+    protected:
+
+        struct SelectorCache {
+            SelectorState state;
+            unsigned int props_size;
+            int *props;
+        };
+
+	unsigned int selectors_size;
+	DOM::CSSSelector **selectors;
+	SelectorCache *selectorCache;
+	unsigned int properties_size;
+	CSSOrderedProperty **properties;
+	TQMemArray<CSSOrderedProperty> inlineProps;
+        TQString m_medium;
+	CSSOrderedProperty **propsToApply;
+	CSSOrderedProperty **pseudoProps;
+	unsigned int propsToApplySize;
+	unsigned int pseudoPropsSize;
+
+
+	RenderStyle::PseudoId dynamicPseudo;
+
+	RenderStyle *style;
+	RenderStyle *parentStyle;
+	DOM::ElementImpl *element;
+	DOM::NodeImpl *parentNode;
+	KHTMLView *view;
+	KHTMLPart *part;
+	const KHTMLSettings *settings;
+	TQPaintDeviceMetrics *paintDeviceMetrics;
+        TQValueVector<int>     m_fontSizes;
+	TQValueVector<int>     m_fixedFontSizes;
+
+	bool fontDirty;
+
+	void applyRule(int id, DOM::CSSValueImpl *value);
+    };
+
+    /*
+     * List of properties that get applied to the Element. We need to collect them first
+     * and then apply them one by one, because we have to change the apply order.
+     * Some properties depend on other one already being applied (for example all properties specifying
+     * some length need to have already the correct font size. Same applies to color
+     *
+     * While sorting them, we have to take care not to mix up the original order.
+     */
+    class CSSOrderedProperty
+    {
+    public:
+	CSSOrderedProperty(DOM::CSSProperty *_prop, uint _selector,
+			   bool first, Source source, unsigned int specificity,
+			   unsigned int _position )
+	    : prop ( _prop ), pseudoId( RenderStyle::NOPSEUDO ), selector( _selector ),
+	      position( _position )
+	{
+	    priority = (!first << 30) | (source << 24) | specificity;
+	}
+
+	bool operator < ( const CSSOrderedProperty &other ) const {
+             if (priority < other.priority) return true;
+             if (priority > other.priority) return false;
+             if (position < other.position) return true;
+             return false;
+	}
+
+	DOM::CSSProperty *prop;
+	RenderStyle::PseudoId pseudoId;
+	unsigned int selector;
+	unsigned int position;
+
+	TQ_UINT32 priority;
+    };
+
+    /*
+     * This is the list we will collect all properties we need to apply in.
+     * It will get sorted once before applying.
+     */
+    class CSSOrderedPropertyList : public TQPtrList<CSSOrderedProperty>
+    {
+    public:
+	virtual int compareItems(TQPtrCollection::Item i1, TQPtrCollection::Item i2);
+	void append(DOM::CSSStyleDeclarationImpl *decl, uint selector, uint specificity,
+		    Source regular, Source important );
+    };
+
+    class CSSOrderedRule
+    {
+    public:
+	CSSOrderedRule(DOM::CSSStyleRuleImpl *r, DOM::CSSSelector *s, int _index);
+	~CSSOrderedRule();
+
+	DOM::CSSSelector *selector;
+	DOM::CSSStyleRuleImpl *rule;
+	int index;
+    };
+
+    class CSSStyleSelectorList : public TQPtrList<CSSOrderedRule>
+    {
+    public:
+	CSSStyleSelectorList();
+	virtual ~CSSStyleSelectorList();
+
+	void append( DOM::CSSStyleSheetImpl *sheet,
+		     const DOM::DOMString &medium = "screen" );
+
+	void collect( TQPtrList<DOM::CSSSelector> *selectorList, CSSOrderedPropertyList *propList,
+		      Source regular, Source important );
+    };
+
+}
+#endif
diff --git a/tdehtml/css/cssvalues.c b/tdehtml/css/cssvalues.c
new file mode 100644
index 000000000..28ceede3d
--- /dev/null
+++ b/tdehtml/css/cssvalues.c
@@ -0,0 +1,1344 @@
+/* ANSI-C code produced by gperf version 3.0.2 */
+/* Command-line: gperf -L ANSI-C -E -c -C -n -o -t -k '*' -NfindValue -Hhash_val -Wwordlist_value -D cssvalues.gperf  */
+
+#if !((' ' == 32) && ('!' == 33) && ('"' == 34) && ('#' == 35) \
+      && ('%' == 37) && ('&' == 38) && ('\'' == 39) && ('(' == 40) \
+      && (')' == 41) && ('*' == 42) && ('+' == 43) && (',' == 44) \
+      && ('-' == 45) && ('.' == 46) && ('/' == 47) && ('0' == 48) \
+      && ('1' == 49) && ('2' == 50) && ('3' == 51) && ('4' == 52) \
+      && ('5' == 53) && ('6' == 54) && ('7' == 55) && ('8' == 56) \
+      && ('9' == 57) && (':' == 58) && (';' == 59) && ('<' == 60) \
+      && ('=' == 61) && ('>' == 62) && ('?' == 63) && ('A' == 65) \
+      && ('B' == 66) && ('C' == 67) && ('D' == 68) && ('E' == 69) \
+      && ('F' == 70) && ('G' == 71) && ('H' == 72) && ('I' == 73) \
+      && ('J' == 74) && ('K' == 75) && ('L' == 76) && ('M' == 77) \
+      && ('N' == 78) && ('O' == 79) && ('P' == 80) && ('Q' == 81) \
+      && ('R' == 82) && ('S' == 83) && ('T' == 84) && ('U' == 85) \
+      && ('V' == 86) && ('W' == 87) && ('X' == 88) && ('Y' == 89) \
+      && ('Z' == 90) && ('[' == 91) && ('\\' == 92) && (']' == 93) \
+      && ('^' == 94) && ('_' == 95) && ('a' == 97) && ('b' == 98) \
+      && ('c' == 99) && ('d' == 100) && ('e' == 101) && ('f' == 102) \
+      && ('g' == 103) && ('h' == 104) && ('i' == 105) && ('j' == 106) \
+      && ('k' == 107) && ('l' == 108) && ('m' == 109) && ('n' == 110) \
+      && ('o' == 111) && ('p' == 112) && ('q' == 113) && ('r' == 114) \
+      && ('s' == 115) && ('t' == 116) && ('u' == 117) && ('v' == 118) \
+      && ('w' == 119) && ('x' == 120) && ('y' == 121) && ('z' == 122) \
+      && ('{' == 123) && ('|' == 124) && ('}' == 125) && ('~' == 126))
+/* The character set is not based on ISO-646.  */
+#error "gperf generated tables don't work with this execution character set. Please report a bug to <bug-gnu-gperf@gnu.org>."
+#endif
+
+#line 1 "cssvalues.gperf"
+
+/* This file is automatically generated from cssvalues.in by makevalues, do not edit */
+/* Copyright 1999 W. Bastian */
+#include "cssvalues.h"
+#line 6 "cssvalues.gperf"
+struct css_value {
+    const char *name;
+    int id;
+};
+
+static const css_value* findValue (register const char *str, register unsigned int len);
+/* maximum key range = 2876, duplicates = 0 */
+
+#ifdef __GNUC__
+__inline
+#else
+#ifdef __cplusplus
+inline
+#endif
+#endif
+static unsigned int
+hash_val (register const char *str, register unsigned int len)
+{
+  static const unsigned short asso_values[] =
+    {
+      2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876,
+      2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876,
+      2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876,
+      2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876,
+      2876, 2876, 2876, 2876, 2876,  420,   23, 2876,    0,    0,
+       105,  100,   40,   35,   20,   15,   10,    5, 2876, 2876,
+      2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876,
+      2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876,
+      2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876,
+      2876, 2876, 2876, 2876, 2876, 2876, 2876,  175,   60,    0,
+        20,   45,   18,  380,  270,    5,    3,   65,    0,   35,
+         0,    5,  265,  465,  100,   20,    5,  195,   18,   13,
+         3,  133,   10, 2876, 2876, 2876, 2876, 2876, 2876, 2876,
+      2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876,
+      2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876,
+      2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876,
+      2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876,
+      2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876,
+      2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876,
+      2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876,
+      2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876,
+      2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876,
+      2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876,
+      2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876,
+      2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876, 2876,
+      2876, 2876, 2876, 2876, 2876, 2876, 2876
+    };
+  register int hval = 0;
+
+  switch (len)
+    {
+      default:
+        hval += asso_values[(unsigned char)str[27]];
+      /*FALLTHROUGH*/
+      case 27:
+        hval += asso_values[(unsigned char)str[26]];
+      /*FALLTHROUGH*/
+      case 26:
+        hval += asso_values[(unsigned char)str[25]];
+      /*FALLTHROUGH*/
+      case 25:
+        hval += asso_values[(unsigned char)str[24]];
+      /*FALLTHROUGH*/
+      case 24:
+        hval += asso_values[(unsigned char)str[23]];
+      /*FALLTHROUGH*/
+      case 23:
+        hval += asso_values[(unsigned char)str[22]];
+      /*FALLTHROUGH*/
+      case 22:
+        hval += asso_values[(unsigned char)str[21]];
+      /*FALLTHROUGH*/
+      case 21:
+        hval += asso_values[(unsigned char)str[20]];
+      /*FALLTHROUGH*/
+      case 20:
+        hval += asso_values[(unsigned char)str[19]];
+      /*FALLTHROUGH*/
+      case 19:
+        hval += asso_values[(unsigned char)str[18]];
+      /*FALLTHROUGH*/
+      case 18:
+        hval += asso_values[(unsigned char)str[17]];
+      /*FALLTHROUGH*/
+      case 17:
+        hval += asso_values[(unsigned char)str[16]];
+      /*FALLTHROUGH*/
+      case 16:
+        hval += asso_values[(unsigned char)str[15]];
+      /*FALLTHROUGH*/
+      case 15:
+        hval += asso_values[(unsigned char)str[14]];
+      /*FALLTHROUGH*/
+      case 14:
+        hval += asso_values[(unsigned char)str[13]];
+      /*FALLTHROUGH*/
+      case 13:
+        hval += asso_values[(unsigned char)str[12]];
+      /*FALLTHROUGH*/
+      case 12:
+        hval += asso_values[(unsigned char)str[11]];
+      /*FALLTHROUGH*/
+      case 11:
+        hval += asso_values[(unsigned char)str[10]];
+      /*FALLTHROUGH*/
+      case 10:
+        hval += asso_values[(unsigned char)str[9]];
+      /*FALLTHROUGH*/
+      case 9:
+        hval += asso_values[(unsigned char)str[8]];
+      /*FALLTHROUGH*/
+      case 8:
+        hval += asso_values[(unsigned char)str[7]];
+      /*FALLTHROUGH*/
+      case 7:
+        hval += asso_values[(unsigned char)str[6]];
+      /*FALLTHROUGH*/
+      case 6:
+        hval += asso_values[(unsigned char)str[5]];
+      /*FALLTHROUGH*/
+      case 5:
+        hval += asso_values[(unsigned char)str[4]];
+      /*FALLTHROUGH*/
+      case 4:
+        hval += asso_values[(unsigned char)str[3]];
+      /*FALLTHROUGH*/
+      case 3:
+        hval += asso_values[(unsigned char)str[2]+1];
+      /*FALLTHROUGH*/
+      case 2:
+        hval += asso_values[(unsigned char)str[1]];
+      /*FALLTHROUGH*/
+      case 1:
+        hval += asso_values[(unsigned char)str[0]];
+        break;
+    }
+  return hval;
+}
+
+#ifdef __GNUC__
+__inline
+#endif
+const struct css_value *
+findValue (register const char *str, register unsigned int len)
+{
+  enum
+    {
+      TOTAL_KEYWORDS = 275,
+      MIN_WORD_LENGTH = 2,
+      MAX_WORD_LENGTH = 28,
+      MIN_HASH_VALUE = 0,
+      MAX_HASH_VALUE = 2875
+    };
+
+  static const struct css_value wordlist_value[] =
+    {
+#line 40 "cssvalues.gperf"
+      {"100", CSS_VAL_100},
+#line 48 "cssvalues.gperf"
+      {"900", CSS_VAL_900},
+#line 47 "cssvalues.gperf"
+      {"800", CSS_VAL_800},
+#line 46 "cssvalues.gperf"
+      {"700", CSS_VAL_700},
+#line 45 "cssvalues.gperf"
+      {"600", CSS_VAL_600},
+#line 216 "cssvalues.gperf"
+      {"ltr", CSS_VAL_LTR},
+#line 277 "cssvalues.gperf"
+      {"down", CSS_VAL_DOWN},
+#line 146 "cssvalues.gperf"
+      {"disc", CSS_VAL_DISC},
+#line 44 "cssvalues.gperf"
+      {"500", CSS_VAL_500},
+#line 43 "cssvalues.gperf"
+      {"400", CSS_VAL_400},
+#line 252 "cssvalues.gperf"
+      {"loud", CSS_VAL_LOUD},
+#line 259 "cssvalues.gperf"
+      {"scroll", CSS_VAL_SCROLL},
+#line 83 "cssvalues.gperf"
+      {"lime", CSS_VAL_LIME},
+#line 17 "cssvalues.gperf"
+      {"none", CSS_VAL_NONE},
+#line 19 "cssvalues.gperf"
+      {"inset", CSS_VAL_INSET},
+#line 118 "cssvalues.gperf"
+      {"window", CSS_VAL_WINDOW},
+#line 287 "cssvalues.gperf"
+      {"content", CSS_VAL_CONTENT},
+#line 147 "cssvalues.gperf"
+      {"circle", CSS_VAL_CIRCLE},
+#line 86 "cssvalues.gperf"
+      {"olive", CSS_VAL_OLIVE},
+#line 33 "cssvalues.gperf"
+      {"italic", CSS_VAL_ITALIC},
+#line 145 "cssvalues.gperf"
+      {"inside", CSS_VAL_INSIDE},
+#line 25 "cssvalues.gperf"
+      {"solid", CSS_VAL_SOLID},
+#line 281 "cssvalues.gperf"
+      {"slide", CSS_VAL_SLIDE},
+#line 183 "cssvalues.gperf"
+      {"inline", CSS_VAL_INLINE},
+#line 262 "cssvalues.gperf"
+      {"static", CSS_VAL_STATIC},
+#line 204 "cssvalues.gperf"
+      {"move", CSS_VAL_MOVE},
+#line 42 "cssvalues.gperf"
+      {"300", CSS_VAL_300},
+#line 250 "cssvalues.gperf"
+      {"level", CSS_VAL_LEVEL},
+#line 41 "cssvalues.gperf"
+      {"200", CSS_VAL_200},
+#line 69 "cssvalues.gperf"
+      {"serif", CSS_VAL_SERIF},
+#line 91 "cssvalues.gperf"
+      {"teal", CSS_VAL_TEAL},
+#line 51 "cssvalues.gperf"
+      {"small", CSS_VAL_SMALL},
+#line 120 "cssvalues.gperf"
+      {"windowtext", CSS_VAL_WINDOWTEXT},
+#line 37 "cssvalues.gperf"
+      {"bold", CSS_VAL_BOLD},
+#line 77 "cssvalues.gperf"
+      {"blue", CSS_VAL_BLUE},
+#line 239 "cssvalues.gperf"
+      {"blink", CSS_VAL_BLINK},
+#line 221 "cssvalues.gperf"
+      {"visible", CSS_VAL_VISIBLE},
+#line 217 "cssvalues.gperf"
+      {"rtl", CSS_VAL_RTL},
+#line 243 "cssvalues.gperf"
+      {"embed", CSS_VAL_EMBED},
+#line 26 "cssvalues.gperf"
+      {"double", CSS_VAL_DOUBLE},
+#line 128 "cssvalues.gperf"
+      {"middle", CSS_VAL_MIDDLE},
+#line 253 "cssvalues.gperf"
+      {"lower", CSS_VAL_LOWER},
+#line 237 "cssvalues.gperf"
+      {"below", CSS_VAL_BELOW},
+#line 63 "cssvalues.gperf"
+      {"condensed", CSS_VAL_CONDENSED},
+#line 78 "cssvalues.gperf"
+      {"crimson", CSS_VAL_CRIMSON},
+#line 14 "cssvalues.gperf"
+      {"inherit", CSS_VAL_INHERIT},
+#line 248 "cssvalues.gperf"
+      {"invert", CSS_VAL_INVERT},
+#line 255 "cssvalues.gperf"
+      {"mix", CSS_VAL_MIX},
+#line 76 "cssvalues.gperf"
+      {"black", CSS_VAL_BLACK},
+#line 213 "cssvalues.gperf"
+      {"text", CSS_VAL_TEXT},
+#line 89 "cssvalues.gperf"
+      {"red", CSS_VAL_RED},
+#line 256 "cssvalues.gperf"
+      {"overline", CSS_VAL_OVERLINE},
+#line 15 "cssvalues.gperf"
+      {"initial", CSS_VAL_INITIAL},
+#line 214 "cssvalues.gperf"
+      {"wait", CSS_VAL_WAIT},
+#line 149 "cssvalues.gperf"
+      {"box", CSS_VAL_BOX},
+#line 139 "cssvalues.gperf"
+      {"center", CSS_VAL_CENTER},
+#line 279 "cssvalues.gperf"
+      {"fast", CSS_VAL_FAST},
+#line 59 "cssvalues.gperf"
+      {"wider", CSS_VAL_WIDER},
+#line 129 "cssvalues.gperf"
+      {"sub", CSS_VAL_SUB},
+#line 244 "cssvalues.gperf"
+      {"fixed", CSS_VAL_FIXED},
+#line 90 "cssvalues.gperf"
+      {"silver", CSS_VAL_SILVER},
+#line 189 "cssvalues.gperf"
+      {"table", CSS_VAL_TABLE},
+#line 270 "cssvalues.gperf"
+      {"enabled", CSS_VAL_ENABLED},
+#line 93 "cssvalues.gperf"
+      {"yellow", CSS_VAL_YELLOW},
+#line 36 "cssvalues.gperf"
+      {"normal", CSS_VAL_NORMAL},
+#line 84 "cssvalues.gperf"
+      {"maroon", CSS_VAL_MAROON},
+#line 286 "cssvalues.gperf"
+      {"border", CSS_VAL_BORDER},
+#line 49 "cssvalues.gperf"
+      {"xx-small", CSS_VAL_XX_SMALL},
+#line 57 "cssvalues.gperf"
+      {"smaller", CSS_VAL_SMALLER},
+#line 207 "cssvalues.gperf"
+      {"nw-resize", CSS_VAL_NW_RESIZE},
+#line 38 "cssvalues.gperf"
+      {"bolder", CSS_VAL_BOLDER},
+#line 284 "cssvalues.gperf"
+      {"clip", CSS_VAL_CLIP},
+#line 28 "cssvalues.gperf"
+      {"icon", CSS_VAL_ICON},
+#line 264 "cssvalues.gperf"
+      {"thin", CSS_VAL_THIN},
+#line 29 "cssvalues.gperf"
+      {"menu", CSS_VAL_MENU},
+#line 210 "cssvalues.gperf"
+      {"sw-resize", CSS_VAL_SW_RESIZE},
+#line 23 "cssvalues.gperf"
+      {"dotted", CSS_VAL_DOTTED},
+#line 206 "cssvalues.gperf"
+      {"ne-resize", CSS_VAL_NE_RESIZE},
+#line 278 "cssvalues.gperf"
+      {"slow", CSS_VAL_SLOW},
+#line 151 "cssvalues.gperf"
+      {"decimal", CSS_VAL_DECIMAL},
+#line 71 "cssvalues.gperf"
+      {"cursive", CSS_VAL_CURSIVE},
+#line 134 "cssvalues.gperf"
+      {"bottom", CSS_VAL_BOTTOM},
+#line 209 "cssvalues.gperf"
+      {"se-resize", CSS_VAL_SE_RESIZE},
+#line 85 "cssvalues.gperf"
+      {"navy", CSS_VAL_NAVY},
+#line 271 "cssvalues.gperf"
+      {"disabled", CSS_VAL_DISABLED},
+#line 127 "cssvalues.gperf"
+      {"baseline", CSS_VAL_BASELINE},
+#line 92 "cssvalues.gperf"
+      {"white", CSS_VAL_WHITE},
+#line 111 "cssvalues.gperf"
+      {"menutext", CSS_VAL_MENUTEXT},
+#line 263 "cssvalues.gperf"
+      {"thick", CSS_VAL_THICK},
+#line 52 "cssvalues.gperf"
+      {"medium", CSS_VAL_MEDIUM},
+#line 140 "cssvalues.gperf"
+      {"justify", CSS_VAL_JUSTIFY},
+#line 246 "cssvalues.gperf"
+      {"hide", CSS_VAL_HIDE},
+#line 275 "cssvalues.gperf"
+      {"reverse", CSS_VAL_REVERSE},
+#line 272 "cssvalues.gperf"
+      {"forwards", CSS_VAL_FORWARDS},
+#line 112 "cssvalues.gperf"
+      {"scrollbar", CSS_VAL_SCROLLBAR},
+#line 228 "cssvalues.gperf"
+      {"pre", CSS_VAL_PRE},
+#line 18 "cssvalues.gperf"
+      {"hidden", CSS_VAL_HIDDEN},
+#line 184 "cssvalues.gperf"
+      {"block", CSS_VAL_BLOCK},
+#line 220 "cssvalues.gperf"
+      {"lowercase", CSS_VAL_LOWERCASE},
+#line 285 "cssvalues.gperf"
+      {"ellipsis", CSS_VAL_ELLIPSIS},
+#line 242 "cssvalues.gperf"
+      {"cross", CSS_VAL_CROSS},
+#line 202 "cssvalues.gperf"
+      {"pointer", CSS_VAL_POINTER},
+#line 258 "cssvalues.gperf"
+      {"relative", CSS_VAL_RELATIVE},
+#line 137 "cssvalues.gperf"
+      {"left", CSS_VAL_LEFT},
+#line 119 "cssvalues.gperf"
+      {"windowframe", CSS_VAL_WINDOWFRAME},
+#line 265 "cssvalues.gperf"
+      {"underline", CSS_VAL_UNDERLINE},
+#line 82 "cssvalues.gperf"
+      {"indigo", CSS_VAL_INDIGO},
+#line 280 "cssvalues.gperf"
+      {"infinite", CSS_VAL_INFINITE},
+#line 110 "cssvalues.gperf"
+      {"infotext", CSS_VAL_INFOTEXT},
+#line 187 "cssvalues.gperf"
+      {"compact", CSS_VAL_COMPACT},
+#line 60 "cssvalues.gperf"
+      {"narrower", CSS_VAL_NARROWER},
+#line 276 "cssvalues.gperf"
+      {"up", CSS_VAL_UP},
+#line 22 "cssvalues.gperf"
+      {"outset", CSS_VAL_OUTSET},
+#line 106 "cssvalues.gperf"
+      {"inactiveborder", CSS_VAL_INACTIVEBORDER},
+#line 245 "cssvalues.gperf"
+      {"hand", CSS_VAL_HAND},
+#line 161 "cssvalues.gperf"
+      {"hebrew", CSS_VAL_HEBREW},
+#line 133 "cssvalues.gperf"
+      {"top", CSS_VAL_TOP},
+#line 236 "cssvalues.gperf"
+      {"avoid", CSS_VAL_AVOID},
+#line 144 "cssvalues.gperf"
+      {"outside", CSS_VAL_OUTSIDE},
+#line 234 "cssvalues.gperf"
+      {"absolute", CSS_VAL_ABSOLUTE},
+#line 162 "cssvalues.gperf"
+      {"armenian", CSS_VAL_ARMENIAN},
+#line 235 "cssvalues.gperf"
+      {"always", CSS_VAL_ALWAYS},
+#line 101 "cssvalues.gperf"
+      {"buttontext", CSS_VAL_BUTTONTEXT},
+#line 185 "cssvalues.gperf"
+      {"list-item", CSS_VAL_LIST_ITEM},
+#line 240 "cssvalues.gperf"
+      {"both", CSS_VAL_BOTH},
+#line 72 "cssvalues.gperf"
+      {"fantasy", CSS_VAL_FANTASY},
+#line 24 "cssvalues.gperf"
+      {"dashed", CSS_VAL_DASHED},
+#line 81 "cssvalues.gperf"
+      {"green", CSS_VAL_GREEN},
+#line 222 "cssvalues.gperf"
+      {"collapse", CSS_VAL_COLLAPSE},
+#line 227 "cssvalues.gperf"
+      {"nowrap", CSS_VAL_NOWRAP},
+#line 269 "cssvalues.gperf"
+      {"content-box", CSS_VAL_CONTENT_BOX},
+#line 73 "cssvalues.gperf"
+      {"monospace", CSS_VAL_MONOSPACE},
+#line 233 "cssvalues.gperf"
+      {"above", CSS_VAL_ABOVE},
+#line 208 "cssvalues.gperf"
+      {"n-resize", CSS_VAL_N_RESIZE},
+#line 261 "cssvalues.gperf"
+      {"show", CSS_VAL_SHOW},
+#line 199 "cssvalues.gperf"
+      {"auto", CSS_VAL_AUTO},
+#line 21 "cssvalues.gperf"
+      {"ridge", CSS_VAL_RIDGE},
+#line 212 "cssvalues.gperf"
+      {"w-resize", CSS_VAL_W_RESIZE},
+#line 257 "cssvalues.gperf"
+      {"portrait", CSS_VAL_PORTRAIT},
+#line 211 "cssvalues.gperf"
+      {"s-resize", CSS_VAL_S_RESIZE},
+#line 87 "cssvalues.gperf"
+      {"orange", CSS_VAL_ORANGE},
+#line 107 "cssvalues.gperf"
+      {"inactivecaption", CSS_VAL_INACTIVECAPTION},
+#line 205 "cssvalues.gperf"
+      {"e-resize", CSS_VAL_E_RESIZE},
+#line 215 "cssvalues.gperf"
+      {"help", CSS_VAL_HELP},
+#line 53 "cssvalues.gperf"
+      {"large", CSS_VAL_LARGE},
+#line 241 "cssvalues.gperf"
+      {"crop", CSS_VAL_CROP},
+#line 121 "cssvalues.gperf"
+      {"grey", CSS_VAL_GREY},
+#line 50 "cssvalues.gperf"
+      {"x-small", CSS_VAL_X_SMALL},
+#line 188 "cssvalues.gperf"
+      {"inline-block", CSS_VAL_INLINE_BLOCK},
+#line 114 "cssvalues.gperf"
+      {"threedface", CSS_VAL_THREEDFACE},
+#line 64 "cssvalues.gperf"
+      {"semi-condensed", CSS_VAL_SEMI_CONDENSED},
+#line 273 "cssvalues.gperf"
+      {"backwards", CSS_VAL_BACKWARDS},
+#line 138 "cssvalues.gperf"
+      {"right", CSS_VAL_RIGHT},
+#line 108 "cssvalues.gperf"
+      {"inactivecaptiontext", CSS_VAL_INACTIVECAPTIONTEXT},
+#line 27 "cssvalues.gperf"
+      {"caption", CSS_VAL_CAPTION},
+#line 274 "cssvalues.gperf"
+      {"ahead", CSS_VAL_AHEAD},
+#line 126 "cssvalues.gperf"
+      {"no-repeat", CSS_VAL_NO_REPEAT},
+#line 80 "cssvalues.gperf"
+      {"gray", CSS_VAL_GRAY},
+#line 197 "cssvalues.gperf"
+      {"table-cell", CSS_VAL_TABLE_CELL},
+#line 39 "cssvalues.gperf"
+      {"lighter", CSS_VAL_LIGHTER},
+#line 98 "cssvalues.gperf"
+      {"buttonface", CSS_VAL_BUTTONFACE},
+#line 79 "cssvalues.gperf"
+      {"fuchsia", CSS_VAL_FUCHSIA},
+#line 249 "cssvalues.gperf"
+      {"landscape", CSS_VAL_LANDSCAPE},
+#line 102 "cssvalues.gperf"
+      {"captiontext", CSS_VAL_CAPTIONTEXT},
+#line 58 "cssvalues.gperf"
+      {"larger", CSS_VAL_LARGER},
+#line 132 "cssvalues.gperf"
+      {"text-bottom", CSS_VAL_TEXT_BOTTOM},
+#line 186 "cssvalues.gperf"
+      {"run-in", CSS_VAL_RUN_IN},
+#line 55 "cssvalues.gperf"
+      {"xx-large", CSS_VAL_XX_LARGE},
+#line 103 "cssvalues.gperf"
+      {"graytext", CSS_VAL_GRAYTEXT},
+#line 268 "cssvalues.gperf"
+      {"border-box", CSS_VAL_BORDER_BOX},
+#line 282 "cssvalues.gperf"
+      {"alternate", CSS_VAL_ALTERNATE},
+#line 174 "cssvalues.gperf"
+      {"lower-latin", CSS_VAL_LOWER_LATIN},
+#line 194 "cssvalues.gperf"
+      {"table-row", CSS_VAL_TABLE_ROW},
+#line 94 "cssvalues.gperf"
+      {"activeborder", CSS_VAL_ACTIVEBORDER},
+#line 66 "cssvalues.gperf"
+      {"expanded", CSS_VAL_EXPANDED},
+#line 74 "cssvalues.gperf"
+      {"transparent", CSS_VAL_TRANSPARENT},
+#line 88 "cssvalues.gperf"
+      {"purple", CSS_VAL_PURPLE},
+#line 190 "cssvalues.gperf"
+      {"inline-table", CSS_VAL_INLINE_TABLE},
+#line 34 "cssvalues.gperf"
+      {"oblique", CSS_VAL_OBLIQUE},
+#line 20 "cssvalues.gperf"
+      {"groove", CSS_VAL_GROOVE},
+#line 201 "cssvalues.gperf"
+      {"default", CSS_VAL_DEFAULT},
+#line 148 "cssvalues.gperf"
+      {"square", CSS_VAL_SQUARE},
+#line 130 "cssvalues.gperf"
+      {"super", CSS_VAL_SUPER},
+#line 70 "cssvalues.gperf"
+      {"sans-serif", CSS_VAL_SANS_SERIF},
+#line 75 "cssvalues.gperf"
+      {"aqua", CSS_VAL_AQUA},
+#line 123 "cssvalues.gperf"
+      {"repeat", CSS_VAL_REPEAT},
+#line 230 "cssvalues.gperf"
+      {"pre-line", CSS_VAL_PRE_LINE},
+#line 283 "cssvalues.gperf"
+      {"unfurl", CSS_VAL_UNFURL},
+#line 238 "cssvalues.gperf"
+      {"bidi-override", CSS_VAL_BIDI_OVERRIDE},
+#line 196 "cssvalues.gperf"
+      {"table-column", CSS_VAL_TABLE_COLUMN},
+#line 131 "cssvalues.gperf"
+      {"text-top", CSS_VAL_TEXT_TOP},
+#line 218 "cssvalues.gperf"
+      {"capitalize", CSS_VAL_CAPITALIZE},
+#line 159 "cssvalues.gperf"
+      {"lower-roman", CSS_VAL_LOWER_ROMAN},
+#line 288 "cssvalues.gperf"
+      {"padding", CSS_VAL_PADDING},
+#line 95 "cssvalues.gperf"
+      {"activecaption", CSS_VAL_ACTIVECAPTION},
+#line 117 "cssvalues.gperf"
+      {"threedshadow", CSS_VAL_THREEDSHADOW},
+#line 200 "cssvalues.gperf"
+      {"crosshair", CSS_VAL_CROSSHAIR},
+#line 247 "cssvalues.gperf"
+      {"higher", CSS_VAL_HIGHER},
+#line 100 "cssvalues.gperf"
+      {"buttonshadow", CSS_VAL_BUTTONSHADOW},
+#line 232 "cssvalues.gperf"
+      {"break-word", CSS_VAL_BREAK_WORD},
+#line 254 "cssvalues.gperf"
+      {"marquee", CSS_VAL_MARQUEE},
+#line 31 "cssvalues.gperf"
+      {"small-caption", CSS_VAL_SMALL_CAPTION},
+#line 35 "cssvalues.gperf"
+      {"small-caps", CSS_VAL_SMALL_CAPS},
+#line 122 "cssvalues.gperf"
+      {"-tdehtml-text", CSS_VAL__KHTML_TEXT},
+#line 141 "cssvalues.gperf"
+      {"-tdehtml-left", CSS_VAL__KHTML_LEFT},
+#line 97 "cssvalues.gperf"
+      {"background", CSS_VAL_BACKGROUND},
+#line 178 "cssvalues.gperf"
+      {"katakana", CSS_VAL_KATAKANA},
+#line 260 "cssvalues.gperf"
+      {"separate", CSS_VAL_SEPARATE},
+#line 32 "cssvalues.gperf"
+      {"status-bar", CSS_VAL_STATUS_BAR},
+#line 65 "cssvalues.gperf"
+      {"semi-expanded", CSS_VAL_SEMI_EXPANDED},
+#line 62 "cssvalues.gperf"
+      {"extra-condensed", CSS_VAL_EXTRA_CONDENSED},
+#line 198 "cssvalues.gperf"
+      {"table-caption", CSS_VAL_TABLE_CAPTION},
+#line 154 "cssvalues.gperf"
+      {"-tdehtml-lao", CSS_VAL__KHTML_LAO},
+#line 143 "cssvalues.gperf"
+      {"-tdehtml-center", CSS_VAL__KHTML_CENTER},
+#line 54 "cssvalues.gperf"
+      {"x-large", CSS_VAL_X_LARGE},
+#line 30 "cssvalues.gperf"
+      {"message-box", CSS_VAL_MESSAGE_BOX},
+#line 203 "cssvalues.gperf"
+      {"progress", CSS_VAL_PROGRESS},
+#line 16 "cssvalues.gperf"
+      {"-tdehtml-native", CSS_VAL__KHTML_NATIVE},
+#line 177 "cssvalues.gperf"
+      {"hiragana", CSS_VAL_HIRAGANA},
+#line 171 "cssvalues.gperf"
+      {"lower-greek", CSS_VAL_LOWER_GREEK},
+#line 150 "cssvalues.gperf"
+      {"-tdehtml-diamond", CSS_VAL__KHTML_DIAMOND},
+#line 224 "cssvalues.gperf"
+      {"no-close-quote", CSS_VAL_NO_CLOSE_QUOTE},
+#line 61 "cssvalues.gperf"
+      {"ultra-condensed", CSS_VAL_ULTRA_CONDENSED},
+#line 158 "cssvalues.gperf"
+      {"-tdehtml-tibetan", CSS_VAL__KHTML_TIBETAN},
+#line 124 "cssvalues.gperf"
+      {"repeat-x", CSS_VAL_REPEAT_X},
+#line 266 "cssvalues.gperf"
+      {"-tdehtml-normal", CSS_VAL__KHTML_NORMAL},
+#line 113 "cssvalues.gperf"
+      {"threeddarkshadow", CSS_VAL_THREEDDARKSHADOW},
+#line 219 "cssvalues.gperf"
+      {"uppercase", CSS_VAL_UPPERCASE},
+#line 136 "cssvalues.gperf"
+      {"-tdehtml-auto", CSS_VAL__KHTML_AUTO},
+#line 163 "cssvalues.gperf"
+      {"georgian", CSS_VAL_GEORGIAN},
+#line 229 "cssvalues.gperf"
+      {"pre-wrap", CSS_VAL_PRE_WRAP},
+#line 125 "cssvalues.gperf"
+      {"repeat-y", CSS_VAL_REPEAT_Y},
+#line 109 "cssvalues.gperf"
+      {"infobackground", CSS_VAL_INFOBACKGROUND},
+#line 157 "cssvalues.gperf"
+      {"-tdehtml-thai", CSS_VAL__KHTML_THAI},
+#line 226 "cssvalues.gperf"
+      {"open-quote", CSS_VAL_OPEN_QUOTE},
+#line 173 "cssvalues.gperf"
+      {"lower-alpha", CSS_VAL_LOWER_ALPHA},
+#line 156 "cssvalues.gperf"
+      {"-tdehtml-urdu", CSS_VAL__KHTML_URDU},
+#line 223 "cssvalues.gperf"
+      {"close-quote", CSS_VAL_CLOSE_QUOTE},
+#line 104 "cssvalues.gperf"
+      {"highlight", CSS_VAL_HIGHLIGHT},
+#line 225 "cssvalues.gperf"
+      {"no-open-quote", CSS_VAL_NO_OPEN_QUOTE},
+#line 231 "cssvalues.gperf"
+      {"-tdehtml-nowrap", CSS_VAL__KHTML_NOWRAP},
+#line 67 "cssvalues.gperf"
+      {"extra-expanded", CSS_VAL_EXTRA_EXPANDED},
+#line 105 "cssvalues.gperf"
+      {"highlighttext", CSS_VAL_HIGHLIGHTTEXT},
+#line 155 "cssvalues.gperf"
+      {"-tdehtml-persian", CSS_VAL__KHTML_PERSIAN},
+#line 116 "cssvalues.gperf"
+      {"threedlightshadow", CSS_VAL_THREEDLIGHTSHADOW},
+#line 96 "cssvalues.gperf"
+      {"appworkspace", CSS_VAL_APPWORKSPACE},
+#line 68 "cssvalues.gperf"
+      {"ultra-expanded", CSS_VAL_ULTRA_EXPANDED},
+#line 176 "cssvalues.gperf"
+      {"upper-latin", CSS_VAL_UPPER_LATIN},
+#line 164 "cssvalues.gperf"
+      {"cjk-ideographic", CSS_VAL_CJK_IDEOGRAPHIC},
+#line 251 "cssvalues.gperf"
+      {"line-through", CSS_VAL_LINE_THROUGH},
+#line 142 "cssvalues.gperf"
+      {"-tdehtml-right", CSS_VAL__KHTML_RIGHT},
+#line 160 "cssvalues.gperf"
+      {"upper-roman", CSS_VAL_UPPER_ROMAN},
+#line 135 "cssvalues.gperf"
+      {"-tdehtml-baseline-middle", CSS_VAL__KHTML_BASELINE_MIDDLE},
+#line 153 "cssvalues.gperf"
+      {"-tdehtml-arabic-indic", CSS_VAL__KHTML_ARABIC_INDIC},
+#line 152 "cssvalues.gperf"
+      {"decimal-leading-zero", CSS_VAL_DECIMAL_LEADING_ZERO},
+#line 115 "cssvalues.gperf"
+      {"threedhighlight", CSS_VAL_THREEDHIGHLIGHT},
+#line 180 "cssvalues.gperf"
+      {"katakana-iroha", CSS_VAL_KATAKANA_IROHA},
+#line 99 "cssvalues.gperf"
+      {"buttonhighlight", CSS_VAL_BUTTONHIGHLIGHT},
+#line 56 "cssvalues.gperf"
+      {"-tdehtml-xxx-large", CSS_VAL__KHTML_XXX_LARGE},
+#line 267 "cssvalues.gperf"
+      {"-tdehtml-around-floats", CSS_VAL__KHTML_AROUND_FLOATS},
+#line 191 "cssvalues.gperf"
+      {"table-row-group", CSS_VAL_TABLE_ROW_GROUP},
+#line 182 "cssvalues.gperf"
+      {"-tdehtml-close-quote", CSS_VAL__KHTML_CLOSE_QUOTE},
+#line 179 "cssvalues.gperf"
+      {"hiragana-iroha", CSS_VAL_HIRAGANA_IROHA},
+#line 193 "cssvalues.gperf"
+      {"table-footer-group", CSS_VAL_TABLE_FOOTER_GROUP},
+#line 195 "cssvalues.gperf"
+      {"table-column-group", CSS_VAL_TABLE_COLUMN_GROUP},
+#line 175 "cssvalues.gperf"
+      {"upper-alpha", CSS_VAL_UPPER_ALPHA},
+#line 181 "cssvalues.gperf"
+      {"-tdehtml-open-quote", CSS_VAL__KHTML_OPEN_QUOTE},
+#line 165 "cssvalues.gperf"
+      {"-tdehtml-japanese-formal", CSS_VAL__KHTML_JAPANESE_FORMAL},
+#line 166 "cssvalues.gperf"
+      {"-tdehtml-japanese-informal", CSS_VAL__KHTML_JAPANESE_INFORMAL},
+#line 192 "cssvalues.gperf"
+      {"table-header-group", CSS_VAL_TABLE_HEADER_GROUP},
+#line 169 "cssvalues.gperf"
+      {"-tdehtml-trad-chinese-formal", CSS_VAL__KHTML_TRAD_CHINESE_FORMAL},
+#line 170 "cssvalues.gperf"
+      {"-tdehtml-trad-chinese-informal", CSS_VAL__KHTML_TRAD_CHINESE_INFORMAL},
+#line 167 "cssvalues.gperf"
+      {"-tdehtml-simp-chinese-formal", CSS_VAL__KHTML_SIMP_CHINESE_FORMAL},
+#line 168 "cssvalues.gperf"
+      {"-tdehtml-simp-chinese-informal", CSS_VAL__KHTML_SIMP_CHINESE_INFORMAL},
+#line 172 "cssvalues.gperf"
+      {"-tdehtml-upper-greek", CSS_VAL__KHTML_UPPER_GREEK}
+    };
+
+  static const short lookup[] =
+    {
+        0,  -1,  -1,  -1,  -1,   1,  -1,  -1,  -1,  -1,
+        2,  -1,  -1,  -1,  -1,   3,  -1,  -1,  -1,  -1,
+        4,  -1,  -1,  -1,  -1,   5,  -1,  -1,   6,  -1,
+        7,  -1,  -1,  -1,  -1,   8,  -1,  -1,  -1,  -1,
+        9,  -1,  -1,  10,  -1,  11,  -1,  -1,  -1,  -1,
+       12,  -1,  -1,  -1,  -1,  13,  -1,  -1,  -1,  -1,
+       14,  15,  -1,  -1,  -1,  16,  -1,  -1,  -1,  -1,
+       17,  18,  -1,  -1,  -1,  19,  -1,  -1,  -1,  -1,
+       20,  -1,  -1,  -1,  -1,  21,  -1,  -1,  22,  -1,
+       23,  -1,  -1,  -1,  -1,  24,  -1,  -1,  25,  -1,
+       26,  -1,  -1,  27,  -1,  28,  -1,  -1,  29,  -1,
+       30,  -1,  -1,  -1,  -1,  31,  -1,  -1,  -1,  32,
+       33,  -1,  -1,  34,  -1,  -1,  -1,  -1,  35,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  36,  -1,
+       37,  -1,  -1,  -1,  -1,  38,  -1,  -1,  39,  -1,
+       40,  -1,  -1,  41,  -1,  -1,  -1,  -1,  42,  -1,
+       43,  -1,  -1,  44,  -1,  45,  -1,  -1,  46,  -1,
+       -1,  -1,  -1,  47,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  48,  -1,  -1,  49,  -1,
+       50,  51,  -1,  52,  -1,  -1,  53,  -1,  54,  -1,
+       55,  -1,  -1,  56,  -1,  -1,  -1,  -1,  57,  -1,
+       -1,  -1,  -1,  -1,  -1,  58,  -1,  -1,  -1,  -1,
+       -1,  59,  -1,  60,  -1,  61,  -1,  -1,  -1,  -1,
+       62,  63,  -1,  -1,  -1,  64,  -1,  -1,  -1,  -1,
+       65,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       66,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  67,
+       68,  69,  -1,  -1,  -1,  70,  -1,  -1,  71,  -1,
+       72,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  73,  -1,
+       74,  75,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       76,  -1,  -1,  77,  -1,  -1,  -1,  -1,  78,  -1,
+       79,  -1,  -1,  80,  -1,  81,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  82,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  83,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       84,  -1,  -1,  -1,  -1,  85,  86,  -1,  87,  -1,
+       -1,  -1,  -1,  88,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       89,  -1,  -1,  -1,  90,  91,  -1,  -1,  92,  -1,
+       -1,  93,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       94,  -1,  -1,  95,  -1,  96,  -1,  -1,  -1,  -1,
+       97,  -1,  -1,  98,  -1,  99,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1, 100,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1, 101,  -1,  -1,  -1,  -1, 102,  -1,
+      103,  -1,  -1,  -1, 104, 105,  -1,  -1,  -1,  -1,
+      106,  -1,  -1,  -1,  -1, 107,  -1,  -1, 108,  -1,
+      109,  -1,  -1,  -1,  -1,  -1,  -1,  -1, 110,  -1,
+      111,  -1,  -1,  -1,  -1, 112,  -1,  -1, 113,  -1,
+      114,  -1,  -1, 115,  -1, 116,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1, 117,  -1, 118,  -1,  -1,  -1,  -1,
+      119,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+      120,  -1,  -1,  -1,  -1,  -1, 121,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1, 122,  -1,
+       -1,  -1,  -1,  -1,  -1, 123,  -1,  -1,  -1,  -1,
+      124, 125,  -1,  -1,  -1, 126,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1, 127,  -1, 128,  -1,  -1, 129,  -1,
+       -1,  -1,  -1, 130,  -1, 131,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1, 132,  -1, 133,  -1,  -1, 134,  -1,
+      135,  -1,  -1,  -1,  -1, 136,  -1,  -1, 137,  -1,
+      138,  -1,  -1,  -1,  -1, 139,  -1,  -1,  -1,  -1,
+      140,  -1,  -1, 141,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+      142,  -1,  -1,  -1,  -1, 143,  -1,  -1,  -1,  -1,
+      144,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+      145, 146,  -1,  -1,  -1,  -1,  -1,  -1, 147,  -1,
+      148,  -1,  -1, 149,  -1, 150,  -1,  -1, 151,  -1,
+      152, 153,  -1,  -1,  -1, 154,  -1,  -1, 155,  -1,
+       -1,  -1,  -1, 156,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1, 157,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+      158,  -1,  -1,  -1,  -1, 159,  -1,  -1, 160,  -1,
+       -1,  -1,  -1, 161,  -1, 162,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1, 163,  -1,  -1,  -1,  -1,  -1,  -1,
+      164,  -1,  -1, 165,  -1, 166,  -1,  -1,  -1, 167,
+       -1, 168,  -1,  -1,  -1,  -1,  -1,  -1, 169,  -1,
+      170,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1, 171,  -1,
+       -1,  -1,  -1, 172,  -1,  -1,  -1,  -1, 173,  -1,
+       -1,  -1,  -1, 174,  -1, 175,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+      176,  -1,  -1,  -1,  -1, 177,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+      178,  -1,  -1, 179,  -1,  -1,  -1,  -1,  -1,  -1,
+      180,  -1,  -1, 181,  -1, 182,  -1,  -1, 183,  -1,
+       -1,  -1,  -1, 184,  -1, 185,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1, 186,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+      187,  -1,  -1, 188,  -1,  -1,  -1,  -1,  -1,  -1,
+      189,  -1,  -1, 190,  -1, 191,  -1,  -1, 192,  -1,
+      193,  -1,  -1, 194,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1, 195,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1, 196,  -1,  -1,  -1,  -1,
+      197,  -1,  -1, 198,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1, 199,  -1,  -1,  -1,
+      200,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+      201,  -1,  -1,  -1,  -1, 202,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1, 203,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1, 204,  -1,
+      205,  -1,  -1,  -1,  -1, 206,  -1,  -1,  -1,  -1,
+      207,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+      208,  -1,  -1, 209,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1, 210,  -1,  -1,  -1,  -1,  -1,  -1,
+      211,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+      212,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1, 213,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1, 214,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1, 215,  -1, 216,  -1,  -1, 217,  -1,
+      218,  -1,  -1,  -1,  -1,  -1,  -1,  -1, 219,  -1,
+      220,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1, 221,  -1,  -1,  -1,  -1,  -1,  -1,
+      222,  -1,  -1,  -1,  -1, 223,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1, 224,  -1,
+       -1,  -1,  -1,  -1,  -1, 225,  -1,  -1, 226,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+      227,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+      228,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+      229,  -1,  -1,  -1,  -1,  -1, 230,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1, 231,  -1,
+      232,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1, 233,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1, 234,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1, 235,  -1,
+      236,  -1,  -1,  -1,  -1, 237,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1, 238,  -1,  -1, 239,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1, 240,  -1,
+       -1, 241,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1, 242,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+      243,  -1,  -1,  -1,  -1,  -1,  -1,  -1, 244,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1, 245,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1, 246,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1, 247,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1, 248,  -1,  -1,  -1,  -1,  -1,  -1,
+      249,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+      250,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1, 251,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1, 252,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1, 253,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1, 254,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+      255,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+      256,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1, 257,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1, 258,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1, 259,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1, 260,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1, 261,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1, 262,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1, 263,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1, 264,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1, 265,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+      266,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1, 267,  -1,  -1,  -1,  -1, 268,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1, 269,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1, 270,  -1,
+       -1,  -1,  -1, 271,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1, 272,  -1,  -1,  -1,  -1, 273,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,  -1,
+       -1,  -1,  -1,  -1,  -1, 274
+    };
+
+  if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
+    {
+      register int key = hash_val (str, len);
+
+      if (key <= MAX_HASH_VALUE && key >= 0)
+        {
+          register int index = lookup[key];
+
+          if (index >= 0)
+            {
+              register const char *s = wordlist_value[index].name;
+
+              if (*str == *s && !strncmp (str + 1, s + 1, len - 1) && s[len] == '\0')
+                return &wordlist_value[index];
+            }
+        }
+    }
+  return 0;
+}
+#line 289 "cssvalues.gperf"
+
+static const char * const valueList[] = {
+"",
+"inherit", 
+"initial", 
+"-tdehtml-native", 
+"none", 
+"hidden", 
+"inset", 
+"groove", 
+"ridge", 
+"outset", 
+"dotted", 
+"dashed", 
+"solid", 
+"double", 
+"caption", 
+"icon", 
+"menu", 
+"message-box", 
+"small-caption", 
+"status-bar", 
+"italic", 
+"oblique", 
+"small-caps", 
+"normal", 
+"bold", 
+"bolder", 
+"lighter", 
+"100", 
+"200", 
+"300", 
+"400", 
+"500", 
+"600", 
+"700", 
+"800", 
+"900", 
+"xx-small", 
+"x-small", 
+"small", 
+"medium", 
+"large", 
+"x-large", 
+"xx-large", 
+"-tdehtml-xxx-large", 
+"smaller", 
+"larger", 
+"wider", 
+"narrower", 
+"ultra-condensed", 
+"extra-condensed", 
+"condensed", 
+"semi-condensed", 
+"semi-expanded", 
+"expanded", 
+"extra-expanded", 
+"ultra-expanded", 
+"serif", 
+"sans-serif", 
+"cursive", 
+"fantasy", 
+"monospace", 
+"transparent", 
+"aqua", 
+"black", 
+"blue", 
+"crimson", 
+"fuchsia", 
+"gray", 
+"green", 
+"indigo", 
+"lime", 
+"maroon", 
+"navy", 
+"olive", 
+"orange", 
+"purple", 
+"red", 
+"silver", 
+"teal", 
+"white", 
+"yellow", 
+"activeborder", 
+"activecaption", 
+"appworkspace", 
+"background", 
+"buttonface", 
+"buttonhighlight", 
+"buttonshadow", 
+"buttontext", 
+"captiontext", 
+"graytext", 
+"highlight", 
+"highlighttext", 
+"inactiveborder", 
+"inactivecaption", 
+"inactivecaptiontext", 
+"infobackground", 
+"infotext", 
+"menutext", 
+"scrollbar", 
+"threeddarkshadow", 
+"threedface", 
+"threedhighlight", 
+"threedlightshadow", 
+"threedshadow", 
+"window", 
+"windowframe", 
+"windowtext", 
+"grey", 
+"-tdehtml-text", 
+"repeat", 
+"repeat-x", 
+"repeat-y", 
+"no-repeat", 
+"baseline", 
+"middle", 
+"sub", 
+"super", 
+"text-top", 
+"text-bottom", 
+"top", 
+"bottom", 
+"-tdehtml-baseline-middle", 
+"-tdehtml-auto", 
+"left", 
+"right", 
+"center", 
+"justify", 
+"-tdehtml-left", 
+"-tdehtml-right", 
+"-tdehtml-center", 
+"outside", 
+"inside", 
+"disc", 
+"circle", 
+"square", 
+"box", 
+"-tdehtml-diamond", 
+"decimal", 
+"decimal-leading-zero", 
+"-tdehtml-arabic-indic", 
+"-tdehtml-lao", 
+"-tdehtml-persian", 
+"-tdehtml-urdu", 
+"-tdehtml-thai", 
+"-tdehtml-tibetan", 
+"lower-roman", 
+"upper-roman", 
+"hebrew", 
+"armenian", 
+"georgian", 
+"cjk-ideographic", 
+"-tdehtml-japanese-formal", 
+"-tdehtml-japanese-informal", 
+"-tdehtml-simp-chinese-formal", 
+"-tdehtml-simp-chinese-informal", 
+"-tdehtml-trad-chinese-formal", 
+"-tdehtml-trad-chinese-informal", 
+"lower-greek", 
+"-tdehtml-upper-greek", 
+"lower-alpha", 
+"lower-latin", 
+"upper-alpha", 
+"upper-latin", 
+"hiragana", 
+"katakana", 
+"hiragana-iroha", 
+"katakana-iroha", 
+"-tdehtml-open-quote", 
+"-tdehtml-close-quote", 
+"inline", 
+"block", 
+"list-item", 
+"run-in", 
+"compact", 
+"inline-block", 
+"table", 
+"inline-table", 
+"table-row-group", 
+"table-header-group", 
+"table-footer-group", 
+"table-row", 
+"table-column-group", 
+"table-column", 
+"table-cell", 
+"table-caption", 
+"auto", 
+"crosshair", 
+"default", 
+"pointer", 
+"progress", 
+"move", 
+"e-resize", 
+"ne-resize", 
+"nw-resize", 
+"n-resize", 
+"se-resize", 
+"sw-resize", 
+"s-resize", 
+"w-resize", 
+"text", 
+"wait", 
+"help", 
+"ltr", 
+"rtl", 
+"capitalize", 
+"uppercase", 
+"lowercase", 
+"visible", 
+"collapse", 
+"close-quote", 
+"no-close-quote", 
+"no-open-quote", 
+"open-quote", 
+"nowrap", 
+"pre", 
+"pre-wrap", 
+"pre-line", 
+"-tdehtml-nowrap", 
+"break-word", 
+"above", 
+"absolute", 
+"always", 
+"avoid", 
+"below", 
+"bidi-override", 
+"blink", 
+"both", 
+"crop", 
+"cross", 
+"embed", 
+"fixed", 
+"hand", 
+"hide", 
+"higher", 
+"invert", 
+"landscape", 
+"level", 
+"line-through", 
+"loud", 
+"lower", 
+"marquee", 
+"mix", 
+"overline", 
+"portrait", 
+"relative", 
+"scroll", 
+"separate", 
+"show", 
+"static", 
+"thick", 
+"thin", 
+"underline", 
+"-tdehtml-normal", 
+"-tdehtml-around-floats", 
+"border-box", 
+"content-box", 
+"enabled", 
+"disabled", 
+"forwards", 
+"backwards", 
+"ahead", 
+"reverse", 
+"up", 
+"down", 
+"slow", 
+"fast", 
+"infinite", 
+"slide", 
+"alternate", 
+"unfurl", 
+"clip", 
+"ellipsis", 
+"border", 
+"content", 
+"padding", 
+    0
+};
+DOMString getValueName(unsigned short id)
+{
+    if(id >= CSS_VAL_TOTAL || id == 0)
+      return DOMString();
+    else
+      return DOMString(valueList[id]);
+}
+
diff --git a/tdehtml/css/cssvalues.h b/tdehtml/css/cssvalues.h
new file mode 100644
index 000000000..36a365754
--- /dev/null
+++ b/tdehtml/css/cssvalues.h
@@ -0,0 +1,290 @@
+/* This file is automatically generated from cssvalues.in by
+#makevalues, do not edit */
+/* Copyright 1998 W. Bastian */
+
+#ifndef CSSVALUES_H
+#define CSSVALUES_H
+
+DOM::DOMString getValueName(unsigned short id) KDE_NO_EXPORT;
+
+#define CSS_VAL_INVALID 0
+#define CSS_VAL_MIN 1
+#define CSS_VAL_INHERIT 1
+#define CSS_VAL_INITIAL 2
+#define CSS_VAL__KHTML_NATIVE 3
+#define CSS_VAL_NONE 4
+#define CSS_VAL_HIDDEN 5
+#define CSS_VAL_INSET 6
+#define CSS_VAL_GROOVE 7
+#define CSS_VAL_RIDGE 8
+#define CSS_VAL_OUTSET 9
+#define CSS_VAL_DOTTED 10
+#define CSS_VAL_DASHED 11
+#define CSS_VAL_SOLID 12
+#define CSS_VAL_DOUBLE 13
+#define CSS_VAL_CAPTION 14
+#define CSS_VAL_ICON 15
+#define CSS_VAL_MENU 16
+#define CSS_VAL_MESSAGE_BOX 17
+#define CSS_VAL_SMALL_CAPTION 18
+#define CSS_VAL_STATUS_BAR 19
+#define CSS_VAL_ITALIC 20
+#define CSS_VAL_OBLIQUE 21
+#define CSS_VAL_SMALL_CAPS 22
+#define CSS_VAL_NORMAL 23
+#define CSS_VAL_BOLD 24
+#define CSS_VAL_BOLDER 25
+#define CSS_VAL_LIGHTER 26
+#define CSS_VAL_100 27
+#define CSS_VAL_200 28
+#define CSS_VAL_300 29
+#define CSS_VAL_400 30
+#define CSS_VAL_500 31
+#define CSS_VAL_600 32
+#define CSS_VAL_700 33
+#define CSS_VAL_800 34
+#define CSS_VAL_900 35
+#define CSS_VAL_XX_SMALL 36
+#define CSS_VAL_X_SMALL 37
+#define CSS_VAL_SMALL 38
+#define CSS_VAL_MEDIUM 39
+#define CSS_VAL_LARGE 40
+#define CSS_VAL_X_LARGE 41
+#define CSS_VAL_XX_LARGE 42
+#define CSS_VAL__KHTML_XXX_LARGE 43
+#define CSS_VAL_SMALLER 44
+#define CSS_VAL_LARGER 45
+#define CSS_VAL_WIDER 46
+#define CSS_VAL_NARROWER 47
+#define CSS_VAL_ULTRA_CONDENSED 48
+#define CSS_VAL_EXTRA_CONDENSED 49
+#define CSS_VAL_CONDENSED 50
+#define CSS_VAL_SEMI_CONDENSED 51
+#define CSS_VAL_SEMI_EXPANDED 52
+#define CSS_VAL_EXPANDED 53
+#define CSS_VAL_EXTRA_EXPANDED 54
+#define CSS_VAL_ULTRA_EXPANDED 55
+#define CSS_VAL_SERIF 56
+#define CSS_VAL_SANS_SERIF 57
+#define CSS_VAL_CURSIVE 58
+#define CSS_VAL_FANTASY 59
+#define CSS_VAL_MONOSPACE 60
+#define CSS_VAL_TRANSPARENT 61
+#define CSS_VAL_AQUA 62
+#define CSS_VAL_BLACK 63
+#define CSS_VAL_BLUE 64
+#define CSS_VAL_CRIMSON 65
+#define CSS_VAL_FUCHSIA 66
+#define CSS_VAL_GRAY 67
+#define CSS_VAL_GREEN 68
+#define CSS_VAL_INDIGO 69
+#define CSS_VAL_LIME 70
+#define CSS_VAL_MAROON 71
+#define CSS_VAL_NAVY 72
+#define CSS_VAL_OLIVE 73
+#define CSS_VAL_ORANGE 74
+#define CSS_VAL_PURPLE 75
+#define CSS_VAL_RED 76
+#define CSS_VAL_SILVER 77
+#define CSS_VAL_TEAL 78
+#define CSS_VAL_WHITE 79
+#define CSS_VAL_YELLOW 80
+#define CSS_VAL_ACTIVEBORDER 81
+#define CSS_VAL_ACTIVECAPTION 82
+#define CSS_VAL_APPWORKSPACE 83
+#define CSS_VAL_BACKGROUND 84
+#define CSS_VAL_BUTTONFACE 85
+#define CSS_VAL_BUTTONHIGHLIGHT 86
+#define CSS_VAL_BUTTONSHADOW 87
+#define CSS_VAL_BUTTONTEXT 88
+#define CSS_VAL_CAPTIONTEXT 89
+#define CSS_VAL_GRAYTEXT 90
+#define CSS_VAL_HIGHLIGHT 91
+#define CSS_VAL_HIGHLIGHTTEXT 92
+#define CSS_VAL_INACTIVEBORDER 93
+#define CSS_VAL_INACTIVECAPTION 94
+#define CSS_VAL_INACTIVECAPTIONTEXT 95
+#define CSS_VAL_INFOBACKGROUND 96
+#define CSS_VAL_INFOTEXT 97
+#define CSS_VAL_MENUTEXT 98
+#define CSS_VAL_SCROLLBAR 99
+#define CSS_VAL_THREEDDARKSHADOW 100
+#define CSS_VAL_THREEDFACE 101
+#define CSS_VAL_THREEDHIGHLIGHT 102
+#define CSS_VAL_THREEDLIGHTSHADOW 103
+#define CSS_VAL_THREEDSHADOW 104
+#define CSS_VAL_WINDOW 105
+#define CSS_VAL_WINDOWFRAME 106
+#define CSS_VAL_WINDOWTEXT 107
+#define CSS_VAL_GREY 108
+#define CSS_VAL__KHTML_TEXT 109
+#define CSS_VAL_REPEAT 110
+#define CSS_VAL_REPEAT_X 111
+#define CSS_VAL_REPEAT_Y 112
+#define CSS_VAL_NO_REPEAT 113
+#define CSS_VAL_BASELINE 114
+#define CSS_VAL_MIDDLE 115
+#define CSS_VAL_SUB 116
+#define CSS_VAL_SUPER 117
+#define CSS_VAL_TEXT_TOP 118
+#define CSS_VAL_TEXT_BOTTOM 119
+#define CSS_VAL_TOP 120
+#define CSS_VAL_BOTTOM 121
+#define CSS_VAL__KHTML_BASELINE_MIDDLE 122
+#define CSS_VAL__KHTML_AUTO 123
+#define CSS_VAL_LEFT 124
+#define CSS_VAL_RIGHT 125
+#define CSS_VAL_CENTER 126
+#define CSS_VAL_JUSTIFY 127
+#define CSS_VAL__KHTML_LEFT 128
+#define CSS_VAL__KHTML_RIGHT 129
+#define CSS_VAL__KHTML_CENTER 130
+#define CSS_VAL_OUTSIDE 131
+#define CSS_VAL_INSIDE 132
+#define CSS_VAL_DISC 133
+#define CSS_VAL_CIRCLE 134
+#define CSS_VAL_SQUARE 135
+#define CSS_VAL_BOX 136
+#define CSS_VAL__KHTML_DIAMOND 137
+#define CSS_VAL_DECIMAL 138
+#define CSS_VAL_DECIMAL_LEADING_ZERO 139
+#define CSS_VAL__KHTML_ARABIC_INDIC 140
+#define CSS_VAL__KHTML_LAO 141
+#define CSS_VAL__KHTML_PERSIAN 142
+#define CSS_VAL__KHTML_URDU 143
+#define CSS_VAL__KHTML_THAI 144
+#define CSS_VAL__KHTML_TIBETAN 145
+#define CSS_VAL_LOWER_ROMAN 146
+#define CSS_VAL_UPPER_ROMAN 147
+#define CSS_VAL_HEBREW 148
+#define CSS_VAL_ARMENIAN 149
+#define CSS_VAL_GEORGIAN 150
+#define CSS_VAL_CJK_IDEOGRAPHIC 151
+#define CSS_VAL__KHTML_JAPANESE_FORMAL 152
+#define CSS_VAL__KHTML_JAPANESE_INFORMAL 153
+#define CSS_VAL__KHTML_SIMP_CHINESE_FORMAL 154
+#define CSS_VAL__KHTML_SIMP_CHINESE_INFORMAL 155
+#define CSS_VAL__KHTML_TRAD_CHINESE_FORMAL 156
+#define CSS_VAL__KHTML_TRAD_CHINESE_INFORMAL 157
+#define CSS_VAL_LOWER_GREEK 158
+#define CSS_VAL__KHTML_UPPER_GREEK 159
+#define CSS_VAL_LOWER_ALPHA 160
+#define CSS_VAL_LOWER_LATIN 161
+#define CSS_VAL_UPPER_ALPHA 162
+#define CSS_VAL_UPPER_LATIN 163
+#define CSS_VAL_HIRAGANA 164
+#define CSS_VAL_KATAKANA 165
+#define CSS_VAL_HIRAGANA_IROHA 166
+#define CSS_VAL_KATAKANA_IROHA 167
+#define CSS_VAL__KHTML_OPEN_QUOTE 168
+#define CSS_VAL__KHTML_CLOSE_QUOTE 169
+#define CSS_VAL_INLINE 170
+#define CSS_VAL_BLOCK 171
+#define CSS_VAL_LIST_ITEM 172
+#define CSS_VAL_RUN_IN 173
+#define CSS_VAL_COMPACT 174
+#define CSS_VAL_INLINE_BLOCK 175
+#define CSS_VAL_TABLE 176
+#define CSS_VAL_INLINE_TABLE 177
+#define CSS_VAL_TABLE_ROW_GROUP 178
+#define CSS_VAL_TABLE_HEADER_GROUP 179
+#define CSS_VAL_TABLE_FOOTER_GROUP 180
+#define CSS_VAL_TABLE_ROW 181
+#define CSS_VAL_TABLE_COLUMN_GROUP 182
+#define CSS_VAL_TABLE_COLUMN 183
+#define CSS_VAL_TABLE_CELL 184
+#define CSS_VAL_TABLE_CAPTION 185
+#define CSS_VAL_AUTO 186
+#define CSS_VAL_CROSSHAIR 187
+#define CSS_VAL_DEFAULT 188
+#define CSS_VAL_POINTER 189
+#define CSS_VAL_PROGRESS 190
+#define CSS_VAL_MOVE 191
+#define CSS_VAL_E_RESIZE 192
+#define CSS_VAL_NE_RESIZE 193
+#define CSS_VAL_NW_RESIZE 194
+#define CSS_VAL_N_RESIZE 195
+#define CSS_VAL_SE_RESIZE 196
+#define CSS_VAL_SW_RESIZE 197
+#define CSS_VAL_S_RESIZE 198
+#define CSS_VAL_W_RESIZE 199
+#define CSS_VAL_TEXT 200
+#define CSS_VAL_WAIT 201
+#define CSS_VAL_HELP 202
+#define CSS_VAL_LTR 203
+#define CSS_VAL_RTL 204
+#define CSS_VAL_CAPITALIZE 205
+#define CSS_VAL_UPPERCASE 206
+#define CSS_VAL_LOWERCASE 207
+#define CSS_VAL_VISIBLE 208
+#define CSS_VAL_COLLAPSE 209
+#define CSS_VAL_CLOSE_QUOTE 210
+#define CSS_VAL_NO_CLOSE_QUOTE 211
+#define CSS_VAL_NO_OPEN_QUOTE 212
+#define CSS_VAL_OPEN_QUOTE 213
+#define CSS_VAL_NOWRAP 214
+#define CSS_VAL_PRE 215
+#define CSS_VAL_PRE_WRAP 216
+#define CSS_VAL_PRE_LINE 217
+#define CSS_VAL__KHTML_NOWRAP 218
+#define CSS_VAL_BREAK_WORD 219
+#define CSS_VAL_ABOVE 220
+#define CSS_VAL_ABSOLUTE 221
+#define CSS_VAL_ALWAYS 222
+#define CSS_VAL_AVOID 223
+#define CSS_VAL_BELOW 224
+#define CSS_VAL_BIDI_OVERRIDE 225
+#define CSS_VAL_BLINK 226
+#define CSS_VAL_BOTH 227
+#define CSS_VAL_CROP 228
+#define CSS_VAL_CROSS 229
+#define CSS_VAL_EMBED 230
+#define CSS_VAL_FIXED 231
+#define CSS_VAL_HAND 232
+#define CSS_VAL_HIDE 233
+#define CSS_VAL_HIGHER 234
+#define CSS_VAL_INVERT 235
+#define CSS_VAL_LANDSCAPE 236
+#define CSS_VAL_LEVEL 237
+#define CSS_VAL_LINE_THROUGH 238
+#define CSS_VAL_LOUD 239
+#define CSS_VAL_LOWER 240
+#define CSS_VAL_MARQUEE 241
+#define CSS_VAL_MIX 242
+#define CSS_VAL_OVERLINE 243
+#define CSS_VAL_PORTRAIT 244
+#define CSS_VAL_RELATIVE 245
+#define CSS_VAL_SCROLL 246
+#define CSS_VAL_SEPARATE 247
+#define CSS_VAL_SHOW 248
+#define CSS_VAL_STATIC 249
+#define CSS_VAL_THICK 250
+#define CSS_VAL_THIN 251
+#define CSS_VAL_UNDERLINE 252
+#define CSS_VAL__KHTML_NORMAL 253
+#define CSS_VAL__KHTML_AROUND_FLOATS 254
+#define CSS_VAL_BORDER_BOX 255
+#define CSS_VAL_CONTENT_BOX 256
+#define CSS_VAL_ENABLED 257
+#define CSS_VAL_DISABLED 258
+#define CSS_VAL_FORWARDS 259
+#define CSS_VAL_BACKWARDS 260
+#define CSS_VAL_AHEAD 261
+#define CSS_VAL_REVERSE 262
+#define CSS_VAL_UP 263
+#define CSS_VAL_DOWN 264
+#define CSS_VAL_SLOW 265
+#define CSS_VAL_FAST 266
+#define CSS_VAL_INFINITE 267
+#define CSS_VAL_SLIDE 268
+#define CSS_VAL_ALTERNATE 269
+#define CSS_VAL_UNFURL 270
+#define CSS_VAL_CLIP 271
+#define CSS_VAL_ELLIPSIS 272
+#define CSS_VAL_BORDER 273
+#define CSS_VAL_CONTENT 274
+#define CSS_VAL_PADDING 275
+
+#define CSS_VAL_TOTAL 276
+#endif
+
diff --git a/tdehtml/css/cssvalues.in b/tdehtml/css/cssvalues.in
new file mode 100644
index 000000000..b85d49f17
--- /dev/null
+++ b/tdehtml/css/cssvalues.in
@@ -0,0 +1,478 @@
+# These are all values accepted for CSS2.
+#
+# WARNING:
+# --------
+#
+# The Values are sorted according to the properties they belong to,
+# and have to be in the same order as the enums in render_style.h.
+#
+# If not, the optimizations in the cssparser and style selector will fail,
+# and produce incorrect results.
+#
+inherit
+initial
+#
+# CSS_PROP_OUTLINE_STYLE
+# CSS_PROP_BORDER_TOP_STYLE
+# CSS_PROP_BORDER_BOTTOM_STYLE
+# CSS_PROP_BORDER_LEFT_STYLE
+-tdehtml-native
+none
+hidden
+inset
+groove
+ridge
+outset
+dotted
+dashed
+solid
+double
+#
+# CSS_PROP_FONT:
+#
+caption
+icon
+menu
+message-box
+small-caption
+status-bar
+#
+# CSS_PROP_FONT_STYLE:
+#
+#normal
+italic
+oblique
+#
+# CSS_PROP_FONT_VARIANT:
+#
+#normal
+small-caps
+#
+# CSS_PROP_FONT_WEIGHT:
+#
+normal
+bold
+bolder
+lighter
+100
+200
+300
+400
+500
+600
+700
+800
+900
+#
+# CSS_PROP_FONT_SIZE:
+#
+xx-small
+x-small
+small
+medium
+large
+x-large
+xx-large
+-tdehtml-xxx-large
+smaller
+larger
+#
+# CSS_PROP_FONT_STRETCH:
+#
+#normal
+wider
+narrower
+ultra-condensed
+extra-condensed
+condensed
+semi-condensed
+semi-expanded
+expanded
+extra-expanded
+ultra-expanded
+#
+# CSS_PROP_GENERIC_FONT_FAMILY:
+#
+serif
+sans-serif
+cursive
+fantasy
+monospace
+#
+#
+# CSS_PROP_BACKGROUND_COLOR:
+#
+transparent
+#
+#
+# CSS_PROP_*_COLOR
+#
+aqua
+black
+blue
+crimson
+fuchsia
+gray
+green
+indigo
+lime
+maroon
+navy
+olive
+orange
+purple
+red
+silver
+teal
+white
+yellow
+activeborder
+activecaption
+appworkspace
+background
+buttonface
+buttonhighlight
+buttonshadow
+buttontext
+captiontext
+graytext
+highlight
+highlighttext
+inactiveborder
+inactivecaption
+inactivecaptiontext
+infobackground
+infotext
+menutext
+scrollbar
+threeddarkshadow
+threedface
+threedhighlight
+threedlightshadow
+threedshadow
+window
+windowframe
+windowtext
+#
+# colors in non strict mode
+grey
+-tdehtml-text
+#
+# CSS_PROP_BACKGROUND_REPEAT:
+#
+repeat
+repeat-x
+repeat-y
+no-repeat
+#
+# CSS_PROP_VERTICAL_ALIGN:
+#
+baseline
+middle
+sub
+super
+text-top
+text-bottom
+top
+bottom
+# HTML alignment MIDDLE has no corresponding CSS alignment
+-tdehtml-baseline-middle
+#
+# CSS_PROP_TEXT_ALIGN:
+#
+-tdehtml-auto
+left
+right
+center
+justify
+-tdehtml-left
+-tdehtml-right
+-tdehtml-center
+#
+# CSS_PROP_LIST_STYLE_POSITION:
+#
+outside
+inside
+#
+# CSS_PROP_LIST_STYLE_TYPE:
+#
+disc
+circle
+square
+box
+-tdehtml-diamond
+decimal
+decimal-leading-zero
+-tdehtml-arabic-indic
+-tdehtml-lao
+-tdehtml-persian
+-tdehtml-urdu
+-tdehtml-thai
+-tdehtml-tibetan
+lower-roman
+upper-roman
+hebrew
+armenian
+georgian
+cjk-ideographic
+-tdehtml-japanese-formal
+-tdehtml-japanese-informal
+-tdehtml-simp-chinese-formal
+-tdehtml-simp-chinese-informal
+-tdehtml-trad-chinese-formal
+-tdehtml-trad-chinese-informal
+lower-greek
+-tdehtml-upper-greek
+lower-alpha
+lower-latin
+upper-alpha
+upper-latin
+hiragana
+katakana
+hiragana-iroha
+katakana-iroha
+-tdehtml-open-quote
+-tdehtml-close-quote
+#none
+#
+# CSS_PROP_DISPLAY:
+#
+inline
+block
+list-item
+run-in
+compact
+inline-block
+table
+inline-table
+table-row-group
+table-header-group
+table-footer-group
+table-row
+table-column-group
+table-column
+table-cell
+table-caption
+#none
+#
+# CSS_PROP_CURSOR:
+#
+auto
+crosshair
+default
+pointer
+progress
+move
+e-resize
+ne-resize
+nw-resize
+n-resize
+se-resize
+sw-resize
+s-resize
+w-resize
+text
+wait
+help
+#
+# CSS_PROP_DIRECTION:
+#
+ltr
+rtl
+#
+# CSS_PROP_TEXT_TRANSFORM:
+#
+capitalize
+uppercase
+lowercase
+#none
+#
+# CSS_PROP_VISIBILITY:
+#
+visible
+#hidden
+collapse
+#
+# CSS_PROP_CONTENT:
+#
+close-quote
+no-close-quote
+no-open-quote
+open-quote
+#
+# CSS_PROP_WHITE_SPACE:
+#
+#normal
+nowrap
+pre
+pre-wrap
+pre-line
+-tdehtml-nowrap
+#
+# CSS_PROP_WORD_WRAP
+#
+#normal
+break-word
+#
+# Unordered rest
+#
+above
+absolute
+always
+avoid
+below
+bidi-override
+blink
+both
+crop
+cross
+embed
+fixed
+hand
+hide
+higher
+invert
+landscape
+level
+line-through
+loud
+lower
+marquee
+mix
+overline
+portrait
+relative
+scroll
+separate
+show
+static
+thick
+thin
+underline
+#
+# CSS_PROP__KHTML_FLOW_MODE
+-tdehtml-normal
+-tdehtml-around-floats
+
+# CSS3 Values
+# CSS_PROP__KHTML_BOX_SIZING
+border-box
+content-box
+
+# CSS_PROP__KHTML_USER_INPUT
+enabled
+disabled
+#none
+
+# CSS_PROP_MARQUEE_DIRECTION
+forwards
+backwards
+ahead
+reverse
+# left
+# right
+up
+down
+# auto
+
+# CSS_PROP_MARQUEE_SPEED
+slow
+# normal
+fast
+
+# CSS_PROP_MARQUEE_REPETITION
+infinite
+
+# CSS_PROP_MARQUEE_STYLE
+# none
+slide
+# scroll
+alternate
+unfurl
+
+#
+# CSS_PROP_TEXT_OVERFLOW
+#
+clip
+ellipsis
+
+#
+# CSS_PROP_BACKGROUND_CLIP/ORIGIN
+#
+border
+content
+padding
+
+#
+# Not supported:
+#
+# CSS_PROP_BORDER_IMAGE
+#
+# stretch
+# repeat
+# round
+#
+# CSS_PROP_AZIMUTH:
+#
+#A left-side
+#A far-left
+#A #left
+#A center-left
+#A #center
+#A center-right
+#A right
+#A far-right
+#A right-side
+#A behind
+#A leftwards
+#A rightwards
+#
+# CSS_PROP_SPEECH_RATE:
+#
+#A x-slow
+#A slow
+#A #medium
+#A x-fast
+#A fast
+#A faster
+#A slower
+#
+# CSS_PROP_VOLUME:
+#
+#A silent
+#A x-soft
+#A soft
+#A #medium
+#A high
+#A x-high
+#A x-loud
+#
+# CSS_PROP_PITCH:
+#
+#A x-low
+#A low
+#A #medium
+#A #high
+#A #x-high
+#
+# CSS_PROP_SPEAK:
+#
+#A #normal
+#A #none
+#A spell-out
+#
+# CSS_PROP_SPEAK_HEADER:
+#
+#A #once
+#A always
+#
+# CSS_PROP_SPEAK_NUMERAL:
+#
+#A digits
+#A continuous
+#
+# CSS_PROP_SPEAK_PUNCTUATION:
+#
+#A code
+#A #none
+
diff --git a/tdehtml/css/html4.css b/tdehtml/css/html4.css
new file mode 100644
index 000000000..ffd599601
--- /dev/null
+++ b/tdehtml/css/html4.css
@@ -0,0 +1,549 @@
+/*
+ * The default style sheet used by tdehtml to render HTML pages
+ * (C) 2000-2003 Lars Knoll (knoll@kde.org)
+ *
+ * Konqueror/tdehtml relies on the existence of this style sheet for
+ * rendering. Do not remove or modify this file unless you know
+ * what you are doing.
+ */
+
+@namespace "http://www.w3.org/1999/xhtml";
+
+html {
+	display: block;
+	color: -tdehtml-text;
+}
+
+/*
+ * head and it's children all have display=none
+ */
+
+head {
+	display: none;
+}
+
+meta {
+	display: none;
+}
+
+title {
+	display: none;
+}
+
+link {
+	display: none;
+}
+
+style {
+	display: none;
+}
+
+script {
+	display: none;
+}
+
+/*
+ * generic block level elements
+ */
+
+@media print {
+	body {
+		display: block;
+		margin: 0px;
+	}
+}
+
+@media screen {
+	body {
+		display: block;
+		margin: 10px;
+	}
+}
+
+p {
+	display: block;
+	margin: 1.0__qem 0px;
+}
+
+div {
+	display: block;
+}
+
+/* to force a block level context for some cases (broken HTML) */
+
+layer {
+	display: block;
+}
+
+address {
+	display: block;
+}
+
+blockquote {
+	display: block;
+        margin: 1__qem 40px 1em 40px;
+}
+
+q        {
+         display: inline;
+}
+
+q:before {
+        content: open-quote;
+}
+
+q:after  {
+        content: close-quote;
+}
+
+center {
+	display: block;
+	/* special centering to be able to emulate the html4/netscape behavior */
+	text-align: -tdehtml-center;
+}
+
+hr  {
+        display: block;
+        margin: 12px auto;
+        border-style: inset;
+        border-width: 1px;
+        -tdehtml-flow-mode: -tdehtml-around-floats
+}
+
+map {
+	display: inline;
+}
+
+/*
+ * heading elements
+ * margin values rely on font-sizes ratio defined in css-2.1 15.7
+ * (cf. cssstyleselector for absolute font-sizes computation)
+ * we have an 1.1/font-ratio margin
+ */
+
+h1 {
+	display: block;
+	font-size: xx-large;
+	margin: .55__qem 0 .55em 0;
+	font-weight: bolder;
+}
+
+h2 {
+	display: block;
+	font-size: x-large;
+	margin: .73__qem 0 .73em 0;
+	font-weight: bolder;
+}
+
+h3 {
+	display: block;
+	font-size: large;
+	margin: 0.92__qem 0 0.92em 0;
+	font-weight: bolder;
+}
+
+h4 {
+	display: block;
+        font-size: medium;
+	margin: 1.1__qem 0 1.1em 0;
+	font-weight: bolder;
+}
+
+h5 {
+	display: block;
+	font-size: small;
+	margin: 1.24__qem 0 1.24em 0;
+	font-weight: bolder;
+}
+
+h6 {
+	display: block;
+	font-size: xx-small;
+	margin: 1.83__qem 0 1.83em 0;
+	font-weight: bolder;
+}
+
+/*
+ * tables
+ */
+
+table {
+	display: table;
+	border-collapse: separate;
+	border-spacing: 2px;
+        -tdehtml-flow-mode: -tdehtml-around-floats;
+        box-sizing: border-box;
+}
+
+table[align="center"] {
+	margin-left: auto;
+	margin-right: auto;
+}
+
+table[align="left"] {
+	float: -tdehtml-left;
+}
+
+table[align="right"] {
+	float: -tdehtml-right;
+}
+
+thead {
+	display: table-header-group;
+        border-color: inherit;
+	vertical-align: middle;
+}
+
+tbody {
+	display: table-row-group;
+        border-color: inherit;
+	vertical-align: middle;
+}
+
+tfoot {
+	display: table-footer-group;
+        border-color: inherit;
+	vertical-align: middle;
+}
+
+col {
+	display: table-column;
+}
+
+colgroup {
+	display: table-column-group;
+}
+
+tr {
+	display: table-row;
+	vertical-align: inherit;
+        border-color: inherit;
+}
+
+
+td, th {
+	display: table-cell;
+	vertical-align: inherit;
+}
+
+th {
+	font-weight: bolder;
+}
+
+caption {
+	display: table-caption;
+	text-align: -tdehtml-center;
+}
+
+/*
+ * lists
+ */
+
+ul, menu, dir {
+        display: block;
+        list-style-type: disc;
+        margin: 1__qem 0 1em 0;
+        -tdehtml-padding-start: 40px
+}
+
+ol {
+        display: block;
+        list-style-type: decimal;
+        margin: 1__qem 0 1em 0;
+        -tdehtml-padding-start: 40px
+}
+
+li {
+        display: list-item;
+        -tdehtml-flow-mode: -tdehtml-around-floats;
+}
+
+
+ul ul, ol ul {
+	list-style-type: circle;
+}
+
+ol ol ul, ol ul ul, ul ol ul, ul ul ul {
+	list-style-type: square;
+}
+
+
+dd {
+	display: block;
+}
+
+dl > dd {
+	-tdehtml-margin-start: 40px;
+}
+
+dl {
+	display: block;
+        margin: 1__qem 0 1em 0;
+}
+
+dt {
+	display: block;
+}
+
+dl[compact] > dt {
+	display: compact;
+}
+
+ol ul,
+ul ol,
+ul ul,
+ol ol {
+	margin-top: auto;
+	margin-bottom: auto;
+}
+
+li > p {
+	margin-top: auto;
+/*	margin-bottom: auto;*/
+}
+
+li > div {
+	margin-top: auto;
+/*	margin-bottom: auto;*/
+}
+
+/*
+ * form elements
+ */
+
+form {
+	display: block;
+        margin: 0__qem 0 1em 0;
+}
+
+legend {
+        display: block;
+        padding-left: 2px;
+        padding-right: 2px;
+        border: none;
+        margin: 0;
+}
+
+fieldset {
+	display: block;
+        padding: 0.75em 0.625em;
+	margin: 1.0em 0;
+        border: 2px groove threedface;
+        -tdehtml-flow-mode: -tdehtml-around-floats
+}
+
+button {
+        display: inline-block;
+        border: 2px outset buttonface;
+        background-color: buttonface;
+        color: buttontext;
+        padding: 2px 2px 2px 2px;
+        cursor: default;
+}
+
+button:active {
+        border-style: inset;
+}
+
+input, textarea {
+        text-align: -tdehtml-auto;
+}
+
+input, textarea, select, button {
+        font-weight: normal;
+        margin: 0__qem;
+}
+
+input { color: windowtext;
+        font-family: sans-serif;
+        font-size: small;
+        border: 2px -tdehtml-native;
+}
+
+input[type="hidden"] {
+	display: none;
+}
+
+input[type="radio"], input[type="checkbox"] {
+        margin: 0 0.5ex;
+        color: buttontext;
+}
+
+input[type="text"], input[type="password"] {
+	cursor: text;
+}
+
+input[type="submit"], input[type="reset"], input[type="button"] {
+        color: buttontext;
+}
+
+isindex { color: windowtext; font-size: small; }
+
+
+option,
+optgroup,
+area,
+param  {
+	display: none;
+}
+
+select {
+        font-family: sans-serif;
+        font-size: small;
+        color: windowtext;
+}
+
+textarea {
+        color: windowtext;
+        font-family: monospace;
+        border: 2px -tdehtml-native;
+}
+
+/*
+ * inline elements
+ */
+
+u,
+ins {
+	text-decoration: underline;
+}
+
+strong,
+b {
+	font-weight: bolder;
+}
+
+i,
+cite,
+em,
+var,
+address {
+	font-style: italic;
+}
+
+tt,
+code,
+kbd,
+samp {
+	font-family: monospace;
+}
+
+pre,
+xmp,
+plaintext {
+	display: block;
+	font-family: monospace;
+	white-space: pre;
+	margin: 1__qem 0;
+}
+
+big {
+	font-size: larger;
+}
+
+small {
+	font-size: smaller;
+}
+
+s,
+strike,
+del  {
+	text-decoration: line-through;
+}
+
+sub {
+	vertical-align: sub;
+	font-size: smaller;
+}
+sup {
+	vertical-align: super;
+	font-size: smaller;
+}
+
+abbr, acronym {
+	font-variant: small-caps;
+	letter-spacing: 0.1em
+}
+
+pre[wrap] {
+    white-space: pre-wrap
+}
+
+*|:focus          { outline: 1px dotted invert }
+a:link:active          { color: red; outline: 1px dotted invert; }
+a:visited:active          { color: red; outline: 1px dotted invert; }
+
+/* with the current design it is too expensive to set this default via css
+:before,:after  { white-space: pre-line }
+*/
+
+/* ### use this to replace renderbr
+      br:before       { content: "\n" }
+*/
+
+
+/* bidirectionality settings (do not change) */
+
+bdo[dir="ltr"]  {
+	direction: ltr;
+	unicode-bidi: bidi-override;
+}
+
+bdo[dir="rtl"]  {
+	direction: rtl;
+	unicode-bidi: bidi-override;
+}
+
+/* ### this selector seems to be still broken ...
+      *[dir="ltr"]    { direction: ltr; unicode-bidi: embed }
+      *[dir="rtl"]    { direction: rtl; unicode-bidi: embed }
+*/
+
+/* elements that are block-level in html4 */
+/* ### don't support unicode-bidi at the moment
+      address, blockquote, body, dd, div, dl, dt, fieldset,
+      form, frame, frameset, h1, h2, h3, h4, h5, h6, iframe,
+      noscript, noframes, object, ol, p, ul, applet, center,
+      dir, hr, menu, pre, li, table, tr, thead, tbody, tfoot,
+      col, colgroup, td, th, caption
+                      { unicode-bidi: embed }
+*/
+
+/* end bidi settings */
+
+/*
+ * other elements
+ */
+
+noframes {
+	display: none;
+}
+
+frameset {
+	display: block;
+}
+
+frame {
+	display: block;
+}
+
+nobr {
+        white-space: nowrap;
+}
+
+wbr {
+        white-space: normal;
+}
+
+marquee {
+    display: inline-block;
+    overflow: marquee;
+}
+
+/* noscript is handled internally, as it depends on the html settings */
+
+@media print {
+  h1, h2, h3,
+  h4, h5, h6    { page-break-after: avoid }
+  ul, ol, dl    { page-break-before: avoid }
+}
diff --git a/tdehtml/css/makeprop b/tdehtml/css/makeprop
new file mode 100644
index 000000000..a1a30ac97
--- /dev/null
+++ b/tdehtml/css/makeprop
@@ -0,0 +1,57 @@
+#   This file is part of the KDE libraries
+#
+#   Copyright (C) 1999 Waldo Bastian (bastian@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.
+#
+#----------------------------------------------------------------------------
+#
+#  KDE HTML Widget -- Script to generate cssproperties.c and cssproperties.h
+#
+grep "^[^\#]" cssproperties.in > cssproperties.strip
+
+echo -e '%{\n/* This file is automatically generated from cssproperties.in by makeprop, do not edit */\n/* Copyright 1999 W. Bastian */\n#include "cssproperties.h"\n%}\nstruct props {\n    const char *name;\n    int id;\n};\n\nstatic const struct props * findProp (register const char *str, register unsigned int len);\n\n%%' > cssproperties.gperf
+cat cssproperties.strip | awk '{ do { prop = $0; gsub("-", "_"); print prop ", CSS_PROP_" toupper($0) } while (getline) }' >> cssproperties.gperf
+echo '%%' >> cssproperties.gperf
+echo -e '/* This file is automatically generated from cssproperties.in by makeprop, do not edit */\n/* Copyright 1998 W. Bastian */\n\n#ifndef CSSPROPERTIES_H\n#define CSSPROPERTIES_H\n\nDOM::DOMString getPropertyName(unsigned short id) KDE_NO_EXPORT;\n' > cssproperties.h
+cat cssproperties.strip | awk '{ \
+i=1; \
+print "#define CSS_PROP_INVALID 0"; \
+print "#define CSS_PROP_MIN 1"; \
+do { gsub("-", "_"); print "#define CSS_PROP_" toupper($0) " " i; i = i + 1 } while (getline); \
+print ""; \
+print "#define CSS_PROP_MAX CSS_PROP_Z_INDEX"; \
+print "#define CSS_PROP_TOTAL " i \
+}' >> cssproperties.h
+gperf -a -L 'ANSI-C' -E -C -c -o -t -k '*' -NfindProp -Hhash_prop -Wwordlist_prop -D -s 2 cssproperties.gperf > cssproperties.c || exit 1
+echo -e '#endif\n' >> cssproperties.h
+
+cat cssproperties.strip | awk '{ \
+i=1; \
+print "static const char * const propertyList[] = {"; \
+print "\"\","; \
+do { print "\"" $0 "\", "; i = i + 1 } while (getline); \
+print "    0"; \
+print "};"; \
+print "DOMString getPropertyName(unsigned short id)"; \
+print "{"; \
+print "    if(id >= CSS_PROP_TOTAL || id == 0)"; \
+print "      return DOMString();";\
+print "    else";\
+print "      return DOMString(propertyList[id]);"; \
+print "}"; \
+print ""; \
+}' >> cssproperties.c
diff --git a/tdehtml/css/makevalues b/tdehtml/css/makevalues
new file mode 100755
index 000000000..0f81f1612
--- /dev/null
+++ b/tdehtml/css/makevalues
@@ -0,0 +1,63 @@
+#!/bin/sh
+#   This file is part of the KDE libraries
+#
+#   Copyright (C) 1999 Waldo Bastian (bastian@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.
+#
+#----------------------------------------------------------------------------
+#
+#  KDE HTML Widget -- Script to generate cssvalues.c and cssvalues.h
+#
+grep "^[^\#]" cssvalues.in > cssvalues.strip
+
+echo -e '%{\n/* This file is automatically generated from cssvalues.in by makevalues, do not edit */\n/* Copyright 1999 W. Bastian */\n#include "cssvalues.h"\n%}\nstruct css_value {\n    const char *name;\n    int id;\n};\n\nstatic const css_value* findValue (register const char *str, register unsigned int len);\n\n%%' > cssvalues.gperf
+cat cssvalues.strip | awk '{ do { prop = $0; gsub("-", "_"); print prop ", CSS_VAL_" toupper($0) } while (getline) }' >> cssvalues.gperf
+echo '%%' >> cssvalues.gperf
+echo -e '/* This file is automatically generated from cssvalues.in by
+#makevalues, do not edit */\n/* Copyright 1998 W. Bastian */\n\n#ifndef CSSVALUES_H\n#define CSSVALUES_H\n\nDOM::DOMString getValueName(unsigned short id) KDE_NO_EXPORT;\n' > cssvalues.h
+cat cssvalues.strip | awk '{ \
+i=1; \
+print "#define CSS_VAL_INVALID 0"; \
+print "#define CSS_VAL_MIN 1"; \
+do { gsub("-", "_"); print "#define CSS_VAL_" toupper($0) " " i; i = i + 1 } while (getline); \
+print ""; \
+print "#define CSS_VAL_TOTAL " i \
+}' >> cssvalues.h
+gperf -L 'ANSI-C' -E -c -C -n -o -t -k '*' -NfindValue -Hhash_val -Wwordlist_value -D cssvalues.gperf > cssvalues.c || exit 1
+echo -e '#endif\n' >> cssvalues.h
+
+cat cssvalues.strip | awk '{ \
+i=1; \
+print "static const char * const valueList[] = {"; \
+print "\"\","; \
+do { print "\"" $0 "\", "; i = i + 1 } while (getline); \
+print "    0"; \
+print "};"; \
+print "DOMString getValueName(unsigned short id)"; \
+print "{"; \
+print "    if(id >= CSS_VAL_TOTAL || id == 0)"; \
+print "      return DOMString();";\
+print "    else";\
+print "      return DOMString(valueList[id]);"; \
+print "}"; \
+print ""; \
+}' >> cssvalues.c
+
+
+
+
+
diff --git a/tdehtml/css/parser.cpp b/tdehtml/css/parser.cpp
new file mode 100644
index 000000000..f88b7d002
--- /dev/null
+++ b/tdehtml/css/parser.cpp
@@ -0,0 +1,2875 @@
+/* A Bison parser, made by GNU Bison 1.875d.  */
+
+/*  Skeleton parser for Yacc-like parsing with Bison,
+    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2, or (at your option)
+    any later version.
+
+    This program 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 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.
+*/
+
+/* As a special exception, when this file is copied by Bison into a
+   Bison output file, you may use that output file without restriction.
+   This special exception was added by the Free Software Foundation
+   in version 1.24 of Bison.  */
+
+/* Written by Richard Stallman by simplifying the original so called
+   ``semantic'' parser.  */
+
+/* All symbols defined below should begin with yy or YY, to avoid
+   infringing on user name space.  This should be done even for local
+   variables, as they might otherwise be expanded by user macros.
+   There are some unavoidable exceptions within include files to
+   define necessary library symbols; they are noted "INFRINGES ON
+   USER NAME SPACE" below.  */
+
+/* Identify Bison output.  */
+#define YYBISON 1
+
+/* Skeleton name.  */
+#define YYSKELETON_NAME "yacc.c"
+
+/* Pure parsers.  */
+#define YYPURE 1
+
+/* Using locations.  */
+#define YYLSP_NEEDED 0
+
+/* If NAME_PREFIX is specified substitute the variables and functions
+   names.  */
+#define yyparse cssyyparse
+#define yylex   cssyylex
+#define yyerror cssyyerror
+#define yylval  cssyylval
+#define yychar  cssyychar
+#define yydebug cssyydebug
+#define yynerrs cssyynerrs
+
+
+/* Tokens.  */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+   /* Put the tokens into the symbol table, so that GDB and other debuggers
+      know about them.  */
+   enum yytokentype {
+     UNIMPORTANT_TOK = 258,
+     S = 259,
+     SGML_CD = 260,
+     INCLUDES = 261,
+     DASHMATCH = 262,
+     BEGINSWITH = 263,
+     ENDSWITH = 264,
+     CONTAINS = 265,
+     STRING = 266,
+     IDENT = 267,
+     NTH = 268,
+     HASH = 269,
+     IMPORT_SYM = 270,
+     PAGE_SYM = 271,
+     MEDIA_SYM = 272,
+     FONT_FACE_SYM = 273,
+     CHARSET_SYM = 274,
+     NAMESPACE_SYM = 275,
+     KHTML_RULE_SYM = 276,
+     KHTML_DECLS_SYM = 277,
+     KHTML_VALUE_SYM = 278,
+     IMPORTANT_SYM = 279,
+     QEMS = 280,
+     EMS = 281,
+     EXS = 282,
+     PXS = 283,
+     CMS = 284,
+     MMS = 285,
+     INS = 286,
+     PTS = 287,
+     PCS = 288,
+     DEGS = 289,
+     RADS = 290,
+     GRADS = 291,
+     MSECS = 292,
+     SECS = 293,
+     HERZ = 294,
+     KHERZ = 295,
+     DIMEN = 296,
+     PERCENTAGE = 297,
+     FLOAT = 298,
+     INTEGER = 299,
+     URI = 300,
+     FUNCTION = 301,
+     NOTFUNCTION = 302,
+     UNICODERANGE = 303
+   };
+#endif
+#define UNIMPORTANT_TOK 258
+#define S 259
+#define SGML_CD 260
+#define INCLUDES 261
+#define DASHMATCH 262
+#define BEGINSWITH 263
+#define ENDSWITH 264
+#define CONTAINS 265
+#define STRING 266
+#define IDENT 267
+#define NTH 268
+#define HASH 269
+#define IMPORT_SYM 270
+#define PAGE_SYM 271
+#define MEDIA_SYM 272
+#define FONT_FACE_SYM 273
+#define CHARSET_SYM 274
+#define NAMESPACE_SYM 275
+#define KHTML_RULE_SYM 276
+#define KHTML_DECLS_SYM 277
+#define KHTML_VALUE_SYM 278
+#define IMPORTANT_SYM 279
+#define QEMS 280
+#define EMS 281
+#define EXS 282
+#define PXS 283
+#define CMS 284
+#define MMS 285
+#define INS 286
+#define PTS 287
+#define PCS 288
+#define DEGS 289
+#define RADS 290
+#define GRADS 291
+#define MSECS 292
+#define SECS 293
+#define HERZ 294
+#define KHERZ 295
+#define DIMEN 296
+#define PERCENTAGE 297
+#define FLOAT 298
+#define INTEGER 299
+#define URI 300
+#define FUNCTION 301
+#define NOTFUNCTION 302
+#define UNICODERANGE 303
+
+
+
+
+/* Copy the first part of user declarations.  */
+
+
+
+/*
+ *  This file is part of the KDE libraries
+ *  Copyright (C) 2002-2003 Lars Knoll (knoll@kde.org)
+ *  Copyright (c) 2003 Apple Computer
+ *  Copyright (C) 2003 Dirk Mueller (mueller@kde.org)
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser 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
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <string.h>
+#include <stdlib.h>
+
+#include <dom/dom_string.h>
+#include <xml/dom_docimpl.h>
+#include <css/cssstyleselector.h>
+#include <css/css_ruleimpl.h>
+#include <css/css_stylesheetimpl.h>
+#include <css/css_valueimpl.h>
+#include <misc/htmlhashes.h>
+#include "cssparser.h"
+
+#include <assert.h>
+#include <kdebug.h>
+//#define CSS_DEBUG
+
+using namespace DOM;
+
+//
+// The following file defines the function
+//     const struct props *findProp(const char *word, int len)
+//
+// with 'props->id' a CSS property in the range from CSS_PROP_MIN to
+// (and including) CSS_PROP_TOTAL-1
+
+// turn off inlining to void warning with newer gcc
+#undef __inline
+#define __inline
+#include "cssproperties.c"
+#include "cssvalues.c"
+#undef __inline
+
+int DOM::getPropertyID(const char *tagStr, int len)
+{
+    const struct props *propsPtr = findProp(tagStr, len);
+    if (!propsPtr)
+        return 0;
+
+    return propsPtr->id;
+}
+
+static inline int getValueID(const char *tagStr, int len)
+{
+    const struct css_value *val = findValue(tagStr, len);
+    if (!val)
+        return 0;
+
+    return val->id;
+}
+
+
+#define YYDEBUG 0
+#undef YYMAXDEPTH
+#define YYPARSE_PARAM parser
+
+
+/* Enabling traces.  */
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+
+/* Enabling verbose error messages.  */
+#ifdef YYERROR_VERBOSE
+# undef YYERROR_VERBOSE
+# define YYERROR_VERBOSE 1
+#else
+# define YYERROR_VERBOSE 0
+#endif
+
+#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
+
+typedef union YYSTYPE {
+    CSSRuleImpl *rule;
+    CSSSelector *selector;
+    TQPtrList<CSSSelector> *selectorList;
+    bool ok;
+    MediaListImpl *mediaList;
+    CSSMediaRuleImpl *mediaRule;
+    CSSRuleListImpl *ruleList;
+    ParseString string;
+    float val;
+    int prop_id;
+    unsigned int attribute;
+    unsigned int element;
+    unsigned int ns;
+    CSSSelector::Relation relation;
+    CSSSelector::Match match;
+    bool b;
+    char tok;
+    Value value;
+    ValueList *valueList;
+} YYSTYPE;
+/* Line 191 of yacc.c.  */
+
+# define yystype YYSTYPE /* obsolescent; will be withdrawn */
+# define YYSTYPE_IS_DECLARED 1
+# define YYSTYPE_IS_TRIVIAL 1
+#endif
+
+
+
+/* Copy the second part of user declarations.  */
+
+
+
+static inline int cssyyerror(const char *x )
+{
+#ifdef CSS_DEBUG
+    tqDebug( "%s", x );
+#else
+    Q_UNUSED( x );
+#endif
+    return 1;
+}
+
+static int cssyylex( YYSTYPE *yylval ) {
+    return CSSParser::current()->lex( yylval );
+}
+
+#define null 1
+
+
+
+/* Line 214 of yacc.c.  */
+
+
+#if ! defined (yyoverflow) || YYERROR_VERBOSE
+
+# ifndef YYFREE
+#  define YYFREE free
+# endif
+# ifndef YYMALLOC
+#  define YYMALLOC malloc
+# endif
+
+/* The parser invokes alloca or malloc; define the necessary symbols.  */
+
+# ifdef YYSTACK_USE_ALLOCA
+#  if YYSTACK_USE_ALLOCA
+#   define YYSTACK_ALLOC alloca
+#  endif
+# else
+#  if defined (alloca) || defined (_ALLOCA_H)
+#   define YYSTACK_ALLOC alloca
+#  else
+#   ifdef __GNUC__
+#    define YYSTACK_ALLOC __builtin_alloca
+#   endif
+#  endif
+# endif
+
+# ifdef YYSTACK_ALLOC
+   /* Pacify GCC's `empty if-body' warning. */
+#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
+# else
+#  if defined (__STDC__) || defined (__cplusplus)
+#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+#   define YYSIZE_T size_t
+#  endif
+#  define YYSTACK_ALLOC YYMALLOC
+#  define YYSTACK_FREE YYFREE
+# endif
+#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
+
+
+#if (! defined (yyoverflow) \
+     && (! defined (__cplusplus) \
+	 || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
+
+/* A type that is properly aligned for any stack member.  */
+union yyalloc
+{
+  short int yyss;
+  YYSTYPE yyvs;
+  };
+
+/* The size of the maximum gap between one aligned stack and the next.  */
+# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
+
+/* The size of an array large to enough to hold all stacks, each with
+   N elements.  */
+# define YYSTACK_BYTES(N) \
+     ((N) * (sizeof (short int) + sizeof (YYSTYPE))			\
+      + YYSTACK_GAP_MAXIMUM)
+
+/* Copy COUNT objects from FROM to TO.  The source and destination do
+   not overlap.  */
+# ifndef YYCOPY
+#  if defined (__GNUC__) && 1 < __GNUC__
+#   define YYCOPY(To, From, Count) \
+      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
+#  else
+#   define YYCOPY(To, From, Count)		\
+      do					\
+	{					\
+	  register YYSIZE_T yyi;		\
+	  for (yyi = 0; yyi < (Count); yyi++)	\
+	    (To)[yyi] = (From)[yyi];		\
+	}					\
+      while (0)
+#  endif
+# endif
+
+/* Relocate STACK from its old location to the new one.  The
+   local variables YYSIZE and YYSTACKSIZE give the old and new number of
+   elements in the stack, and YYPTR gives the new location of the
+   stack.  Advance YYPTR to a properly aligned location for the next
+   stack.  */
+# define YYSTACK_RELOCATE(Stack)					\
+    do									\
+      {									\
+	YYSIZE_T yynewbytes;						\
+	YYCOPY (&yyptr->Stack, Stack, yysize);				\
+	Stack = &yyptr->Stack;						\
+	yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
+	yyptr += yynewbytes / sizeof (*yyptr);				\
+      }									\
+    while (0)
+
+#endif
+
+#if defined (__STDC__) || defined (__cplusplus)
+   typedef signed char yysigned_char;
+#else
+   typedef short int yysigned_char;
+#endif
+
+/* YYFINAL -- State number of the termination state. */
+#define YYFINAL  16
+/* YYLAST -- Last index in YYTABLE.  */
+#define YYLAST   479
+
+/* YYNTOKENS -- Number of terminals. */
+#define YYNTOKENS  67
+/* YYNNTS -- Number of nonterminals. */
+#define YYNNTS  54
+/* YYNRULES -- Number of rules. */
+#define YYNRULES  162
+/* YYNRULES -- Number of states. */
+#define YYNSTATES  305
+
+/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
+#define YYUNDEFTOK  2
+#define YYMAXUTOK   303
+
+#define YYTRANSLATE(YYX) 						\
+  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
+
+/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
+static const unsigned char yytranslate[] =
+{
+       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,    64,    18,    58,    57,    61,    16,    65,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,    15,    56,
+       2,    63,    60,     2,    66,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,    17,     2,    62,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,    54,    19,    55,    59,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
+       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
+      20,    21,    22,    23,    24,    25,    26,    27,    28,    29,
+      30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
+      40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
+      50,    51,    52,    53
+};
+
+#if YYDEBUG
+/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
+   YYRHS.  */
+static const unsigned short int yyprhs[] =
+{
+       0,     0,     3,     9,    12,    15,    18,    25,    28,    34,
+      35,    38,    39,    42,    45,    46,    52,    56,    60,    61,
+      65,    72,    76,    80,    81,    85,    92,    96,   100,   101,
+     104,   105,   109,   111,   113,   115,   117,   119,   121,   124,
+     126,   128,   129,   131,   133,   138,   141,   149,   150,   154,
+     157,   161,   165,   169,   173,   176,   179,   182,   183,   185,
+     187,   190,   192,   197,   200,   202,   206,   209,   211,   214,
+     217,   220,   224,   227,   231,   236,   240,   242,   244,   246,
+     249,   252,   254,   256,   258,   260,   263,   266,   271,   280,
+     286,   296,   298,   300,   302,   304,   306,   308,   310,   312,
+     315,   319,   324,   329,   334,   339,   345,   350,   355,   360,
+     366,   372,   376,   380,   385,   390,   396,   399,   402,   405,
+     406,   408,   412,   415,   418,   419,   421,   424,   427,   430,
+     433,   436,   439,   441,   443,   446,   449,   452,   455,   458,
+     461,   464,   467,   470,   473,   476,   479,   482,   485,   488,
+     491,   494,   497,   500,   506,   510,   513,   517,   521,   524,
+     530,   534,   536
+};
+
+/* YYRHS -- A `-1'-separated list of the rules' RHS. */
+static const yysigned_char yyrhs[] =
+{
+      68,     0,    -1,    74,    73,    75,    77,    80,    -1,    69,
+      72,    -1,    70,    72,    -1,    71,    72,    -1,    26,    54,
+      72,    92,    72,    55,    -1,    27,   106,    -1,    28,    54,
+      72,   111,    55,    -1,    -1,    72,     4,    -1,    -1,    73,
+       5,    -1,    73,     4,    -1,    -1,    24,    72,    11,    72,
+      56,    -1,    24,     1,   119,    -1,    24,     1,    56,    -1,
+      -1,    75,    76,    73,    -1,    20,    72,    82,    72,    83,
+      56,    -1,    20,     1,   119,    -1,    20,     1,    56,    -1,
+      -1,    77,    78,    73,    -1,    25,    72,    79,    82,    72,
+      56,    -1,    25,     1,   119,    -1,    25,     1,    56,    -1,
+      -1,    12,     4,    -1,    -1,    80,    81,    73,    -1,    92,
+      -1,    85,    -1,    88,    -1,    89,    -1,   118,    -1,   117,
+      -1,    76,     1,    -1,    11,    -1,    50,    -1,    -1,    84,
+      -1,    87,    -1,    84,    57,    72,    87,    -1,    84,     1,
+      -1,    22,    72,    84,    54,    72,    86,    55,    -1,    -1,
+      86,    92,    72,    -1,    12,    72,    -1,    21,     1,   119,
+      -1,    21,     1,    56,    -1,    23,     1,   119,    -1,    23,
+       1,    56,    -1,    58,    72,    -1,    59,    72,    -1,    60,
+      72,    -1,    -1,    61,    -1,    58,    -1,    93,   106,    -1,
+      94,    -1,    93,    57,    72,    94,    -1,    93,     1,    -1,
+      96,    -1,    94,    90,    96,    -1,    94,     1,    -1,    19,
+      -1,    18,    19,    -1,    12,    19,    -1,    97,    72,    -1,
+      97,    98,    72,    -1,    98,    72,    -1,    95,    97,    72,
+      -1,    95,    97,    98,    72,    -1,    95,    98,    72,    -1,
+      12,    -1,    18,    -1,    99,    -1,    98,    99,    -1,    98,
+       1,    -1,    14,    -1,   100,    -1,   102,    -1,   105,    -1,
+      16,    12,    -1,    12,    72,    -1,    17,    72,   101,    62,
+      -1,    17,    72,   101,   103,    72,   104,    72,    62,    -1,
+      17,    72,    95,   101,    62,    -1,    17,    72,    95,   101,
+     103,    72,   104,    72,    62,    -1,    63,    -1,     6,    -1,
+       7,    -1,     8,    -1,     9,    -1,    10,    -1,    12,    -1,
+      11,    -1,    15,    12,    -1,    15,    15,    12,    -1,    15,
+      51,    13,    64,    -1,    15,    51,    49,    64,    -1,    15,
+      51,    12,    64,    -1,    15,    51,    11,    64,    -1,    15,
+      52,    72,    96,    64,    -1,    54,    72,   108,    55,    -1,
+      54,    72,     1,    55,    -1,    54,    72,   107,    55,    -1,
+      54,    72,   107,   108,    55,    -1,    54,    72,   107,     1,
+      55,    -1,   108,    56,    72,    -1,     1,    56,    72,    -1,
+     107,   108,    56,    72,    -1,   107,     1,    56,    72,    -1,
+     109,    15,    72,   111,   110,    -1,     1,   119,    -1,    12,
+      72,    -1,    29,    72,    -1,    -1,   113,    -1,   111,   112,
+     113,    -1,    65,    72,    -1,    57,    72,    -1,    -1,   114,
+      -1,    91,   114,    -1,    46,    72,    -1,    11,    72,    -1,
+      12,    72,    -1,    50,    72,    -1,    53,    72,    -1,   116,
+      -1,   115,    -1,    49,    72,    -1,    48,    72,    -1,    47,
+      72,    -1,    33,    72,    -1,    34,    72,    -1,    35,    72,
+      -1,    36,    72,    -1,    37,    72,    -1,    38,    72,    -1,
+      39,    72,    -1,    40,    72,    -1,    41,    72,    -1,    42,
+      72,    -1,    43,    72,    -1,    44,    72,    -1,    45,    72,
+      -1,    31,    72,    -1,    30,    72,    -1,    32,    72,    -1,
+      51,    72,   111,    64,    72,    -1,    51,    72,     1,    -1,
+      14,    72,    -1,    66,     1,   119,    -1,    66,     1,    56,
+      -1,     1,   119,    -1,    54,     1,   120,     1,    55,    -1,
+      54,     1,    55,    -1,   119,    -1,   120,     1,   119,    -1
+};
+
+/* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
+static const unsigned short int yyrline[] =
+{
+       0,   257,   257,   258,   259,   260,   264,   271,   277,   302,
+     303,   306,   308,   309,   312,   314,   319,   320,   323,   325,
+     336,   346,   349,   355,   356,   360,   368,   369,   373,   374,
+     377,   379,   390,   391,   392,   393,   394,   395,   396,   400,
+     401,   405,   408,   413,   417,   422,   429,   443,   444,   454,
+     476,   479,   485,   488,   494,   495,   496,   497,   501,   502,
+     506,   526,   540,   555,   562,   565,   579,   586,   587,   588,
+     592,   596,   601,   606,   613,   622,   634,   650,   656,   660,
+     670,   677,   683,   684,   685,   689,   698,   722,   727,   733,
+     741,   753,   756,   759,   762,   765,   768,   774,   775,   779,
+     785,   791,   798,   805,   812,   819,   828,   831,   834,   837,
+     842,   848,   852,   855,   860,   866,   888,   894,   901,   902,
+     906,   910,   926,   929,   932,   938,   939,   941,   942,   943,
+     949,   950,   951,   953,   959,   960,   961,   962,   963,   964,
+     965,   966,   967,   968,   969,   970,   971,   972,   973,   974,
+     975,   976,   977,   982,   990,  1006,  1013,  1019,  1028,  1054,
+    1055,  1059,  1060
+};
+#endif
+
+#if YYDEBUG || YYERROR_VERBOSE
+/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
+   First, the terminals, then, starting at YYNTOKENS, nonterminals. */
+static const char *const yytname[] =
+{
+  "$end", "error", "$undefined", "UNIMPORTANT_TOK", "S", "SGML_CD",
+  "INCLUDES", "DASHMATCH", "BEGINSWITH", "ENDSWITH", "CONTAINS", "STRING",
+  "IDENT", "NTH", "HASH", "':'", "'.'", "'['", "'*'", "'|'", "IMPORT_SYM",
+  "PAGE_SYM", "MEDIA_SYM", "FONT_FACE_SYM", "CHARSET_SYM", "NAMESPACE_SYM",
+  "KHTML_RULE_SYM", "KHTML_DECLS_SYM", "KHTML_VALUE_SYM", "IMPORTANT_SYM",
+  "QEMS", "EMS", "EXS", "PXS", "CMS", "MMS", "INS", "PTS", "PCS", "DEGS",
+  "RADS", "GRADS", "MSECS", "SECS", "HERZ", "KHERZ", "DIMEN", "PERCENTAGE",
+  "FLOAT", "INTEGER", "URI", "FUNCTION", "NOTFUNCTION", "UNICODERANGE",
+  "'{'", "'}'", "';'", "','", "'+'", "'~'", "'>'", "'-'", "']'", "'='",
+  "')'", "'/'", "'@'", "$accept", "stylesheet", "tdehtml_rule",
+  "tdehtml_decls", "tdehtml_value", "maybe_space", "maybe_sgml",
+  "maybe_charset", "import_list", "import", "namespace_list", "namespace",
+  "maybe_ns_prefix", "rule_list", "rule", "string_or_uri",
+  "maybe_media_list", "media_list", "media", "ruleset_list", "medium",
+  "page", "font_face", "combinator", "unary_operator", "ruleset",
+  "selector_list", "selector", "namespace_selector", "simple_selector",
+  "element_name", "specifier_list", "specifier", "class", "attrib_id",
+  "attrib", "match", "ident_or_string", "pseudo", "declaration_block",
+  "declaration_list", "declaration", "property", "prio", "expr",
+  "operator", "term", "unary_term", "function", "hexcolor", "invalid_at",
+  "invalid_rule", "invalid_block", "invalid_block_list", 0
+};
+#endif
+
+# ifdef YYPRINT
+/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
+   token YYLEX-NUM.  */
+static const unsigned short int yytoknum[] =
+{
+       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
+     265,   266,   267,   268,   269,    58,    46,    91,    42,   124,
+     270,   271,   272,   273,   274,   275,   276,   277,   278,   279,
+     280,   281,   282,   283,   284,   285,   286,   287,   288,   289,
+     290,   291,   292,   293,   294,   295,   296,   297,   298,   299,
+     300,   301,   302,   303,   123,   125,    59,    44,    43,   126,
+      62,    45,    93,    61,    41,    47,    64
+};
+# endif
+
+/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
+static const unsigned char yyr1[] =
+{
+       0,    67,    68,    68,    68,    68,    69,    70,    71,    72,
+      72,    73,    73,    73,    74,    74,    74,    74,    75,    75,
+      76,    76,    76,    77,    77,    78,    78,    78,    79,    79,
+      80,    80,    81,    81,    81,    81,    81,    81,    81,    82,
+      82,    83,    83,    84,    84,    84,    85,    86,    86,    87,
+      88,    88,    89,    89,    90,    90,    90,    90,    91,    91,
+      92,    93,    93,    93,    94,    94,    94,    95,    95,    95,
+      96,    96,    96,    96,    96,    96,    97,    97,    98,    98,
+      98,    99,    99,    99,    99,   100,   101,   102,   102,   102,
+     102,   103,   103,   103,   103,   103,   103,   104,   104,   105,
+     105,   105,   105,   105,   105,   105,   106,   106,   106,   106,
+     106,   107,   107,   107,   107,   108,   108,   109,   110,   110,
+     111,   111,   112,   112,   112,   113,   113,   113,   113,   113,
+     113,   113,   113,   113,   114,   114,   114,   114,   114,   114,
+     114,   114,   114,   114,   114,   114,   114,   114,   114,   114,
+     114,   114,   114,   115,   115,   116,   117,   117,   118,   119,
+     119,   120,   120
+};
+
+/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
+static const unsigned char yyr2[] =
+{
+       0,     2,     5,     2,     2,     2,     6,     2,     5,     0,
+       2,     0,     2,     2,     0,     5,     3,     3,     0,     3,
+       6,     3,     3,     0,     3,     6,     3,     3,     0,     2,
+       0,     3,     1,     1,     1,     1,     1,     1,     2,     1,
+       1,     0,     1,     1,     4,     2,     7,     0,     3,     2,
+       3,     3,     3,     3,     2,     2,     2,     0,     1,     1,
+       2,     1,     4,     2,     1,     3,     2,     1,     2,     2,
+       2,     3,     2,     3,     4,     3,     1,     1,     1,     2,
+       2,     1,     1,     1,     1,     2,     2,     4,     8,     5,
+       9,     1,     1,     1,     1,     1,     1,     1,     1,     2,
+       3,     4,     4,     4,     4,     5,     4,     4,     4,     5,
+       5,     3,     3,     4,     4,     5,     2,     2,     2,     0,
+       1,     3,     2,     2,     0,     1,     2,     2,     2,     2,
+       2,     2,     1,     1,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     5,     3,     2,     3,     3,     2,     5,
+       3,     1,     3
+};
+
+/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
+   STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
+   means the default is an error.  */
+static const unsigned char yydefact[] =
+{
+      14,     0,     0,     0,     0,     0,     9,     9,     9,    11,
+       0,     0,     9,     9,     7,     9,     1,     3,     4,     5,
+      18,     0,    17,    16,    10,     9,     0,     0,     0,    13,
+      12,    23,     0,     0,    76,    81,     0,     0,     9,    77,
+      67,     9,     0,     0,     0,    64,     9,     0,    78,    82,
+      83,    84,     0,     9,     0,     0,     0,     9,     9,     9,
+       9,     9,     9,     9,     9,     9,     9,     9,     9,     9,
+       9,     9,     9,     9,     9,     9,     9,     9,     9,     9,
+       9,     9,     9,    59,    58,     0,   124,   120,   125,   133,
+     132,     0,    11,    30,   160,   161,     0,    15,    69,    99,
+       0,     0,     9,    85,     0,    68,     0,    63,     9,    60,
+      66,     9,     9,     9,     0,    76,    77,     9,     0,    70,
+       0,    80,    72,    79,   107,     9,   116,   117,     0,   108,
+       0,   106,     9,     9,   128,   129,   155,   151,   150,   152,
+     137,   138,   139,   140,   141,   142,   143,   144,   145,   146,
+     147,   148,   149,   127,   136,   135,   134,   130,     0,   131,
+     126,     8,     9,     9,     0,     0,     0,    19,     0,    11,
+       0,     0,   100,     0,     0,     0,     0,     0,     9,     0,
+       0,     0,     6,     0,    54,    55,    56,    65,    73,     0,
+      75,    71,   112,   110,     9,   109,     9,   111,     0,   154,
+     124,   123,   122,   121,    22,    21,    39,    40,     9,     0,
+      28,    24,     0,     0,     9,     0,     0,     0,    11,    33,
+      34,    35,    32,    37,    36,   159,   162,   104,   103,   101,
+     102,     0,    86,     9,     0,    92,    93,    94,    95,    96,
+      87,    91,     9,     0,    74,   114,   113,   124,     9,    41,
+      27,    26,     0,     0,   158,     0,     0,     0,     0,    38,
+      31,   105,    89,     9,     0,     9,   115,   153,     9,     0,
+       0,    43,    29,     9,    51,    50,     0,    53,    52,   157,
+     156,     0,    98,    97,     9,   118,    49,    20,    45,     9,
+       0,     9,     9,     0,     0,    25,    47,     0,    88,    44,
+       0,    90,    46,     9,    48
+};
+
+/* YYDEFGOTO[NTERM-NUM]. */
+static const short int yydefgoto[] =
+{
+      -1,     5,     6,     7,     8,   232,    20,     9,    31,    92,
+      93,   169,   253,   170,   218,   208,   269,   270,   219,   300,
+     271,   220,   221,   114,    85,    41,    42,    43,    44,    45,
+      46,    47,    48,    49,   181,    50,   242,   284,    51,    14,
+      54,    55,    56,   266,    86,   164,    87,    88,    89,    90,
+     223,   224,   126,    96
+};
+
+/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
+   STATE-NUM.  */
+#define YYPACT_NINF -167
+static const short int yypact[] =
+{
+     252,    19,   -46,   -32,   -20,    44,  -167,  -167,  -167,  -167,
+     147,   183,  -167,  -167,  -167,  -167,  -167,    96,    96,    96,
+      34,   114,  -167,  -167,  -167,  -167,   333,   156,   355,  -167,
+    -167,    85,    98,    -2,    99,  -167,   158,   109,  -167,   152,
+    -167,  -167,    52,   241,   222,  -167,   229,   162,  -167,  -167,
+    -167,  -167,   215,  -167,   101,   168,   118,  -167,  -167,  -167,
+    -167,  -167,  -167,  -167,  -167,  -167,  -167,  -167,  -167,  -167,
+    -167,  -167,  -167,  -167,  -167,  -167,  -167,  -167,  -167,  -167,
+    -167,  -167,  -167,  -167,  -167,   430,   127,  -167,  -167,  -167,
+    -167,   119,  -167,   160,  -167,  -167,   189,  -167,  -167,  -167,
+     202,   116,  -167,  -167,    14,  -167,   104,  -167,  -167,  -167,
+    -167,  -167,  -167,  -167,   346,  -167,  -167,   229,   162,    96,
+     162,  -167,    96,  -167,  -167,  -167,  -167,    96,   238,  -167,
+     210,  -167,  -167,  -167,    96,    96,    96,    96,    96,    96,
+      96,    96,    96,    96,    96,    96,    96,    96,    96,    96,
+      96,    96,    96,    96,    96,    96,    96,    96,   273,    96,
+    -167,  -167,  -167,  -167,   398,   150,     5,    34,   185,  -167,
+     125,   157,  -167,   154,   169,   217,   218,   333,    99,   152,
+     237,    41,  -167,   333,    96,    96,    96,  -167,    96,   162,
+      96,    96,    96,  -167,  -167,  -167,  -167,    96,   355,  -167,
+     -36,    96,    96,  -167,  -167,  -167,  -167,  -167,  -167,   161,
+     110,    34,   232,   288,  -167,   295,   296,   326,  -167,  -167,
+    -167,  -167,  -167,  -167,  -167,  -167,  -167,  -167,  -167,  -167,
+    -167,   264,    96,  -167,    87,  -167,  -167,  -167,  -167,  -167,
+    -167,  -167,  -167,   324,    96,    96,    96,   143,  -167,   171,
+    -167,  -167,   325,    88,  -167,   198,   171,   207,   219,  -167,
+      34,  -167,  -167,  -167,    31,  -167,  -167,    96,  -167,   274,
+      35,  -167,  -167,  -167,  -167,  -167,    97,  -167,  -167,  -167,
+    -167,    31,  -167,  -167,  -167,    96,    96,  -167,  -167,  -167,
+      79,  -167,  -167,    23,   171,  -167,    96,    27,  -167,  -167,
+     213,  -167,  -167,  -167,    96
+};
+
+/* YYPGOTO[NTERM-NUM].  */
+static const short int yypgoto[] =
+{
+    -167,  -167,  -167,  -167,  -167,    -1,   -82,  -167,  -167,   163,
+    -167,  -167,  -167,  -167,  -167,    82,  -167,    76,  -167,  -167,
+      50,  -167,  -167,  -167,  -167,  -166,  -167,   170,   242,   -95,
+     310,   -29,   -34,  -167,   175,  -167,   122,    89,  -167,   315,
+    -167,   314,  -167,  -167,  -157,  -167,   208,   286,  -167,  -167,
+    -167,  -167,    -7,  -167
+};
+
+/* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
+   positive, shift that token.  If negative, reduce the rule which
+   number is the opposite.  If zero, do what YYDEFACT says.
+   If YYTABLE_NINF, syntax error.  */
+#define YYTABLE_NINF -120
+static const short int yytable[] =
+{
+      11,   200,    24,    23,   222,    17,    18,    19,    12,    24,
+     167,    26,    27,   123,    28,   118,   206,   120,    24,   187,
+      10,   162,    13,    -9,    33,    95,   178,    24,   248,   163,
+      -9,    24,   179,    40,    15,    24,   288,   104,    29,    30,
+     106,   247,   282,   283,    16,   119,   122,   235,   236,   237,
+     238,   239,   127,   107,    97,   207,   134,   135,   136,   137,
+     138,   139,   140,   141,   142,   143,   144,   145,   146,   147,
+     148,   149,   150,   151,   152,   153,   154,   155,   156,   157,
+     158,   159,   231,    24,   123,   298,   123,   211,   189,   301,
+     166,   -42,   289,   235,   236,   237,   238,   239,   288,   206,
+      24,   177,   128,   240,   241,    91,    13,   183,    24,   108,
+     184,   185,   186,    53,    24,    32,   188,   190,    98,   191,
+     165,   103,   252,    -9,   192,    -2,   212,   173,   174,   175,
+      -9,   197,   198,   133,   303,   295,   260,    34,   207,    35,
+      36,    37,    38,    39,    40,    91,   213,   214,   215,   262,
+     241,   291,    21,    94,   289,   123,   129,    52,   205,   182,
+      24,   201,   202,   121,   226,   176,    -9,   210,    53,    -9,
+      99,   105,   265,   100,    -9,    24,    35,    36,    37,    38,
+      -9,    -9,   161,   268,   162,   168,   209,    24,   244,    -9,
+     171,   216,   163,   245,    25,   246,    -9,    -9,  -119,  -119,
+     162,    21,   251,    22,    21,   254,   204,   249,   163,   101,
+     102,    21,   225,   256,   172,    21,    -9,   250,   227,    -9,
+      -9,    -9,    -9,   131,   132,    34,    -9,    35,    36,    37,
+      38,    39,    40,   228,   115,    -9,    35,    36,    37,    38,
+     116,   264,   110,    35,    36,    37,    38,   267,   275,   233,
+     278,   280,    21,   -57,   274,   -57,   -57,   -57,   -57,   -57,
+     -57,    21,   281,   277,   285,   195,   196,   286,   302,    21,
+     124,   125,   290,    21,   199,   279,     1,    24,     2,     3,
+       4,   229,   230,   293,    57,    58,    21,    59,   294,   255,
+     296,   297,    21,   193,   194,   -61,   257,   258,   -61,   111,
+     112,   113,   304,    60,    61,    62,    63,    64,    65,    66,
+      67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
+      77,    78,    79,    80,    81,   110,    82,   259,   261,   272,
+     287,    83,   276,   217,    84,   273,   -57,    24,   -57,   -57,
+     -57,   -57,   -57,   -57,   299,    34,   180,    35,    36,    37,
+      38,    39,    40,   243,   117,   234,   263,   109,    34,    24,
+      35,    36,    37,    38,    39,    40,    57,    58,   130,    59,
+     292,   160,   203,     0,     0,     0,     0,     0,   -62,     0,
+       0,   -62,   111,   112,   113,    60,    61,    62,    63,    64,
+      65,    66,    67,    68,    69,    70,    71,    72,    73,    74,
+      75,    76,    77,    78,    79,    80,    81,     0,    82,    57,
+      58,     0,    59,    83,     0,     0,    84,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,    60,    61,
+      62,    63,    64,    65,    66,    67,    68,    69,    70,    71,
+      72,    73,    74,    75,    76,    77,    78,    79,    80,    81,
+       0,    82,     0,     0,     0,     0,    83,     0,     0,    84,
+      60,    61,    62,    63,    64,    65,    66,    67,    68,    69,
+      70,    71,    72,    73,    74,    75,     0,    77,    78,    79
+};
+
+static const short int yycheck[] =
+{
+       1,   158,     4,    10,   170,     6,     7,     8,    54,     4,
+      92,    12,    13,    47,    15,    44,    11,    46,     4,   114,
+       1,    57,    54,     4,    25,    32,    12,     4,    64,    65,
+      11,     4,    18,    19,    54,     4,     1,    38,     4,     5,
+      41,   198,    11,    12,     0,    46,    47,     6,     7,     8,
+       9,    10,    53,     1,    56,    50,    57,    58,    59,    60,
+      61,    62,    63,    64,    65,    66,    67,    68,    69,    70,
+      71,    72,    73,    74,    75,    76,    77,    78,    79,    80,
+      81,    82,   177,     4,   118,    62,   120,   169,   117,    62,
+      91,    56,    57,     6,     7,     8,     9,    10,     1,    11,
+       4,   102,     1,    62,    63,    20,    54,   108,     4,    57,
+     111,   112,   113,    12,     4,     1,   117,   118,    19,   120,
+       1,    12,    12,     4,   125,     0,     1,    11,    12,    13,
+      11,   132,   133,    15,   300,    56,   218,    12,    50,    14,
+      15,    16,    17,    18,    19,    20,    21,    22,    23,    62,
+      63,    54,    54,    55,    57,   189,    55,     1,   165,    55,
+       4,   162,   163,     1,   171,    49,     4,   168,    12,    50,
+      12,    19,    29,    15,    12,     4,    14,    15,    16,    17,
+      18,    19,    55,    12,    57,    25,     1,     4,   189,     4,
+       1,    66,    65,   194,    11,   196,    11,    12,    55,    56,
+      57,    54,   209,    56,    54,   212,    56,   208,    65,    51,
+      52,    54,    55,   214,    12,    54,    54,    56,    64,    57,
+      58,    59,    60,    55,    56,    12,    64,    14,    15,    16,
+      17,    18,    19,    64,    12,    50,    14,    15,    16,    17,
+      18,   242,     1,    14,    15,    16,    17,   248,   255,    12,
+     257,   258,    54,    12,    56,    14,    15,    16,    17,    18,
+      19,    54,   263,    56,   265,    55,    56,   268,    55,    54,
+      55,    56,   273,    54,     1,    56,    24,     4,    26,    27,
+      28,    64,    64,   284,    11,    12,    54,    14,   289,     1,
+     291,   292,    54,    55,    56,    54,     1,     1,    57,    58,
+      59,    60,   303,    30,    31,    32,    33,    34,    35,    36,
+      37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
+      47,    48,    49,    50,    51,     1,    53,     1,    64,     4,
+      56,    58,   256,   170,    61,   253,    12,     4,    14,    15,
+      16,    17,    18,    19,   294,    12,   104,    14,    15,    16,
+      17,    18,    19,   183,    44,   180,   234,    42,    12,     4,
+      14,    15,    16,    17,    18,    19,    11,    12,    54,    14,
+     281,    85,   164,    -1,    -1,    -1,    -1,    -1,    54,    -1,
+      -1,    57,    58,    59,    60,    30,    31,    32,    33,    34,
+      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
+      45,    46,    47,    48,    49,    50,    51,    -1,    53,    11,
+      12,    -1,    14,    58,    -1,    -1,    61,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    30,    31,
+      32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
+      42,    43,    44,    45,    46,    47,    48,    49,    50,    51,
+      -1,    53,    -1,    -1,    -1,    -1,    58,    -1,    -1,    61,
+      30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
+      40,    41,    42,    43,    44,    45,    -1,    47,    48,    49
+};
+
+/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
+   symbol of state STATE-NUM.  */
+static const unsigned char yystos[] =
+{
+       0,    24,    26,    27,    28,    68,    69,    70,    71,    74,
+       1,    72,    54,    54,   106,    54,     0,    72,    72,    72,
+      73,    54,    56,   119,     4,    11,    72,    72,    72,     4,
+       5,    75,     1,    72,    12,    14,    15,    16,    17,    18,
+      19,    92,    93,    94,    95,    96,    97,    98,    99,   100,
+     102,   105,     1,    12,   107,   108,   109,    11,    12,    14,
+      30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
+      40,    41,    42,    43,    44,    45,    46,    47,    48,    49,
+      50,    51,    53,    58,    61,    91,   111,   113,   114,   115,
+     116,    20,    76,    77,    55,   119,   120,    56,    19,    12,
+      15,    51,    52,    12,    72,    19,    72,     1,    57,   106,
+       1,    58,    59,    60,    90,    12,    18,    97,    98,    72,
+      98,     1,    72,    99,    55,    56,   119,    72,     1,    55,
+     108,    55,    56,    15,    72,    72,    72,    72,    72,    72,
+      72,    72,    72,    72,    72,    72,    72,    72,    72,    72,
+      72,    72,    72,    72,    72,    72,    72,    72,    72,    72,
+     114,    55,    57,    65,   112,     1,    72,    73,    25,    78,
+      80,     1,    12,    11,    12,    13,    49,    72,    12,    18,
+      95,   101,    55,    72,    72,    72,    72,    96,    72,    98,
+      72,    72,    72,    55,    56,    55,    56,    72,    72,     1,
+     111,    72,    72,   113,    56,   119,    11,    50,    82,     1,
+      72,    73,     1,    21,    22,    23,    66,    76,    81,    85,
+      88,    89,    92,   117,   118,    55,   119,    64,    64,    64,
+      64,    96,    72,    12,   101,     6,     7,     8,     9,    10,
+      62,    63,   103,    94,    72,    72,    72,   111,    64,    72,
+      56,   119,    12,    79,   119,     1,    72,     1,     1,     1,
+      73,    64,    62,   103,    72,    29,   110,    72,    12,    83,
+      84,    87,     4,    82,    56,   119,    84,    56,   119,    56,
+     119,    72,    11,    12,   104,    72,    72,    56,     1,    57,
+      72,    54,   104,    72,    72,    56,    72,    72,    62,    87,
+      86,    62,    55,    92,    72
+};
+
+#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
+# define YYSIZE_T __SIZE_TYPE__
+#endif
+#if ! defined (YYSIZE_T) && defined (size_t)
+# define YYSIZE_T size_t
+#endif
+#if ! defined (YYSIZE_T)
+# if defined (__STDC__) || defined (__cplusplus)
+#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+#  define YYSIZE_T size_t
+# endif
+#endif
+#if ! defined (YYSIZE_T)
+# define YYSIZE_T unsigned int
+#endif
+
+#define yyerrok		(yyerrstatus = 0)
+#define yyclearin	(yychar = YYEMPTY)
+#define YYEMPTY		(-2)
+#define YYEOF		0
+
+#define YYACCEPT	goto yyacceptlab
+#define YYABORT		goto yyabortlab
+#define YYERROR		goto yyerrorlab
+
+
+/* Like YYERROR except do call yyerror.  This remains here temporarily
+   to ease the transition to the new meaning of YYERROR, for GCC.
+   Once GCC version 2 has supplanted version 1, this can go.  */
+
+#define YYFAIL		goto yyerrlab
+
+#define YYRECOVERING()  (!!yyerrstatus)
+
+#define YYBACKUP(Token, Value)					\
+do								\
+  if (yychar == YYEMPTY && yylen == 1)				\
+    {								\
+      yychar = (Token);						\
+      yylval = (Value);						\
+      yytoken = YYTRANSLATE (yychar);				\
+      YYPOPSTACK;						\
+      goto yybackup;						\
+    }								\
+  else								\
+    { 								\
+      yyerror ("syntax error: cannot back up");\
+      YYERROR;							\
+    }								\
+while (0)
+
+#define YYTERROR	1
+#define YYERRCODE	256
+
+/* YYLLOC_DEFAULT -- Compute the default location (before the actions
+   are run).  */
+
+#ifndef YYLLOC_DEFAULT
+# define YYLLOC_DEFAULT(Current, Rhs, N)		\
+   ((Current).first_line   = (Rhs)[1].first_line,	\
+    (Current).first_column = (Rhs)[1].first_column,	\
+    (Current).last_line    = (Rhs)[N].last_line,	\
+    (Current).last_column  = (Rhs)[N].last_column)
+#endif
+
+/* YYLEX -- calling `yylex' with the right arguments.  */
+
+#ifdef YYLEX_PARAM
+# define YYLEX yylex (&yylval, YYLEX_PARAM)
+#else
+# define YYLEX yylex (&yylval)
+#endif
+
+/* Enable debugging if requested.  */
+#if YYDEBUG
+
+# ifndef YYFPRINTF
+#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
+#  define YYFPRINTF fprintf
+# endif
+
+# define YYDPRINTF(Args)			\
+do {						\
+  if (yydebug)					\
+    YYFPRINTF Args;				\
+} while (0)
+
+# define YYDSYMPRINT(Args)			\
+do {						\
+  if (yydebug)					\
+    yysymprint Args;				\
+} while (0)
+
+# define YYDSYMPRINTF(Title, Token, Value, Location)		\
+do {								\
+  if (yydebug)							\
+    {								\
+      YYFPRINTF (stderr, "%s ", Title);				\
+      yysymprint (stderr, 					\
+                  Token, Value);	\
+      YYFPRINTF (stderr, "\n");					\
+    }								\
+} while (0)
+
+/*------------------------------------------------------------------.
+| yy_stack_print -- Print the state stack from its BOTTOM up to its |
+| TOP (included).                                                   |
+`------------------------------------------------------------------*/
+
+#if defined (__STDC__) || defined (__cplusplus)
+static void
+yy_stack_print (short int *bottom, short int *top)
+#else
+static void
+yy_stack_print (bottom, top)
+    short int *bottom;
+    short int *top;
+#endif
+{
+  YYFPRINTF (stderr, "Stack now");
+  for (/* Nothing. */; bottom <= top; ++bottom)
+    YYFPRINTF (stderr, " %d", *bottom);
+  YYFPRINTF (stderr, "\n");
+}
+
+# define YY_STACK_PRINT(Bottom, Top)				\
+do {								\
+  if (yydebug)							\
+    yy_stack_print ((Bottom), (Top));				\
+} while (0)
+
+
+/*------------------------------------------------.
+| Report that the YYRULE is going to be reduced.  |
+`------------------------------------------------*/
+
+#if defined (__STDC__) || defined (__cplusplus)
+static void
+yy_reduce_print (int yyrule)
+#else
+static void
+yy_reduce_print (yyrule)
+    int yyrule;
+#endif
+{
+  int yyi;
+  unsigned int yylno = yyrline[yyrule];
+  YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
+             yyrule - 1, yylno);
+  /* Print the symbols being reduced, and their result.  */
+  for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
+    YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
+  YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
+}
+
+# define YY_REDUCE_PRINT(Rule)		\
+do {					\
+  if (yydebug)				\
+    yy_reduce_print (Rule);		\
+} while (0)
+
+/* Nonzero means print parse trace.  It is left uninitialized so that
+   multiple parsers can coexist.  */
+int yydebug;
+#else /* !YYDEBUG */
+# define YYDPRINTF(Args)
+# define YYDSYMPRINT(Args)
+# define YYDSYMPRINTF(Title, Token, Value, Location)
+# define YY_STACK_PRINT(Bottom, Top)
+# define YY_REDUCE_PRINT(Rule)
+#endif /* !YYDEBUG */
+
+
+/* YYINITDEPTH -- initial size of the parser's stacks.  */
+#ifndef	YYINITDEPTH
+# define YYINITDEPTH 200
+#endif
+
+/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
+   if the built-in stack extension method is used).
+
+   Do not make this value too large; the results are undefined if
+   SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
+   evaluated with infinite-precision integer arithmetic.  */
+
+#if defined (YYMAXDEPTH) && YYMAXDEPTH == 0
+# undef YYMAXDEPTH
+#endif
+
+#ifndef YYMAXDEPTH
+# define YYMAXDEPTH 10000
+#endif
+
+
+
+#if YYERROR_VERBOSE
+
+# ifndef yystrlen
+#  if defined (__GLIBC__) && defined (_STRING_H)
+#   define yystrlen strlen
+#  else
+/* Return the length of YYSTR.  */
+static YYSIZE_T
+#   if defined (__STDC__) || defined (__cplusplus)
+yystrlen (const char *yystr)
+#   else
+yystrlen (yystr)
+     const char *yystr;
+#   endif
+{
+  register const char *yys = yystr;
+
+  while (*yys++ != '\0')
+    continue;
+
+  return yys - yystr - 1;
+}
+#  endif
+# endif
+
+# ifndef yystpcpy
+#  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
+#   define yystpcpy stpcpy
+#  else
+/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
+   YYDEST.  */
+static char *
+#   if defined (__STDC__) || defined (__cplusplus)
+yystpcpy (char *yydest, const char *yysrc)
+#   else
+yystpcpy (yydest, yysrc)
+     char *yydest;
+     const char *yysrc;
+#   endif
+{
+  register char *yyd = yydest;
+  register const char *yys = yysrc;
+
+  while ((*yyd++ = *yys++) != '\0')
+    continue;
+
+  return yyd - 1;
+}
+#  endif
+# endif
+
+#endif /* !YYERROR_VERBOSE */
+
+
+
+#if YYDEBUG
+/*--------------------------------.
+| Print this symbol on YYOUTPUT.  |
+`--------------------------------*/
+
+#if defined (__STDC__) || defined (__cplusplus)
+static void
+yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
+#else
+static void
+yysymprint (yyoutput, yytype, yyvaluep)
+    FILE *yyoutput;
+    int yytype;
+    YYSTYPE *yyvaluep;
+#endif
+{
+  /* Pacify ``unused variable'' warnings.  */
+  (void) yyvaluep;
+
+  if (yytype < YYNTOKENS)
+    {
+      YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
+# ifdef YYPRINT
+      YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
+# endif
+    }
+  else
+    YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
+
+  switch (yytype)
+    {
+      default:
+        break;
+    }
+  YYFPRINTF (yyoutput, ")");
+}
+
+#endif /* ! YYDEBUG */
+/*-----------------------------------------------.
+| Release the memory associated to this symbol.  |
+`-----------------------------------------------*/
+
+#if defined (__STDC__) || defined (__cplusplus)
+static void
+yydestruct (int yytype, YYSTYPE *yyvaluep)
+#else
+static void
+yydestruct (yytype, yyvaluep)
+    int yytype;
+    YYSTYPE *yyvaluep;
+#endif
+{
+  /* Pacify ``unused variable'' warnings.  */
+  (void) yyvaluep;
+
+  switch (yytype)
+    {
+      case 83: /* maybe_media_list */
+
+        { delete yyvaluep->mediaList; yyvaluep->mediaList = 0; };
+
+        break;
+      case 84: /* media_list */
+
+        { delete yyvaluep->mediaList; yyvaluep->mediaList = 0; };
+
+        break;
+      case 86: /* ruleset_list */
+
+        { delete yyvaluep->ruleList; yyvaluep->ruleList = 0; };
+
+        break;
+      case 93: /* selector_list */
+
+        { delete yyvaluep->selectorList; yyvaluep->selectorList = 0; };
+
+        break;
+      case 94: /* selector */
+
+        { delete yyvaluep->selector; yyvaluep->selector = 0; };
+
+        break;
+      case 96: /* simple_selector */
+
+        { delete yyvaluep->selector; yyvaluep->selector = 0; };
+
+        break;
+      case 98: /* specifier_list */
+
+        { delete yyvaluep->selector; yyvaluep->selector = 0; };
+
+        break;
+      case 99: /* specifier */
+
+        { delete yyvaluep->selector; yyvaluep->selector = 0; };
+
+        break;
+      case 100: /* class */
+
+        { delete yyvaluep->selector; yyvaluep->selector = 0; };
+
+        break;
+      case 102: /* attrib */
+
+        { delete yyvaluep->selector; yyvaluep->selector = 0; };
+
+        break;
+      case 105: /* pseudo */
+
+        { delete yyvaluep->selector; yyvaluep->selector = 0; };
+
+        break;
+      case 111: /* expr */
+
+        { delete yyvaluep->valueList; yyvaluep->valueList = 0; };
+
+        break;
+
+      default:
+        break;
+    }
+}
+
+
+/* Prevent warnings from -Wmissing-prototypes.  */
+
+#ifdef YYPARSE_PARAM
+# if defined (__STDC__) || defined (__cplusplus)
+int yyparse (void *YYPARSE_PARAM);
+# else
+int yyparse ();
+# endif
+#else /* ! YYPARSE_PARAM */
+#if defined (__STDC__) || defined (__cplusplus)
+int yyparse (void);
+#else
+int yyparse ();
+#endif
+#endif /* ! YYPARSE_PARAM */
+
+
+
+
+
+
+/*----------.
+| yyparse.  |
+`----------*/
+
+#ifdef YYPARSE_PARAM
+# if defined (__STDC__) || defined (__cplusplus)
+int yyparse (void *YYPARSE_PARAM)
+# else
+int yyparse (YYPARSE_PARAM)
+  void *YYPARSE_PARAM;
+# endif
+#else /* ! YYPARSE_PARAM */
+#if defined (__STDC__) || defined (__cplusplus)
+int
+yyparse (void)
+#else
+int
+yyparse ()
+
+#endif
+#endif
+{
+  /* The lookahead symbol.  */
+int yychar;
+
+/* The semantic value of the lookahead symbol.  */
+YYSTYPE yylval;
+
+/* Number of syntax errors so far.  */
+int yynerrs;
+
+  register int yystate;
+  register int yyn;
+  int yyresult;
+  /* Number of tokens to shift before error messages enabled.  */
+  int yyerrstatus;
+  /* Lookahead token as an internal (translated) token number.  */
+  int yytoken = 0;
+
+  /* Three stacks and their tools:
+     `yyss': related to states,
+     `yyvs': related to semantic values,
+     `yyls': related to locations.
+
+     Refer to the stacks thru separate pointers, to allow yyoverflow
+     to reallocate them elsewhere.  */
+
+  /* The state stack.  */
+  short int yyssa[YYINITDEPTH];
+  short int *yyss = yyssa;
+  register short int *yyssp;
+
+  /* The semantic value stack.  */
+  YYSTYPE yyvsa[YYINITDEPTH];
+  YYSTYPE *yyvs = yyvsa;
+  register YYSTYPE *yyvsp;
+
+
+
+#define YYPOPSTACK   (yyvsp--, yyssp--)
+
+  YYSIZE_T yystacksize = YYINITDEPTH;
+
+  /* The variables used to return semantic value and location from the
+     action routines.  */
+  YYSTYPE yyval;
+
+
+  /* When reducing, the number of symbols on the RHS of the reduced
+     rule.  */
+  int yylen;
+
+  YYDPRINTF ((stderr, "Starting parse\n"));
+
+  yystate = 0;
+  yyerrstatus = 0;
+  yynerrs = 0;
+  yychar = YYEMPTY;		/* Cause a token to be read.  */
+
+  /* Initialize stack pointers.
+     Waste one element of value and location stack
+     so that they stay on the same level as the state stack.
+     The wasted elements are never initialized.  */
+
+  yyssp = yyss;
+  yyvsp = yyvs;
+
+
+  goto yysetstate;
+
+/*------------------------------------------------------------.
+| yynewstate -- Push a new state, which is found in yystate.  |
+`------------------------------------------------------------*/
+ yynewstate:
+  /* In all cases, when you get here, the value and location stacks
+     have just been pushed. so pushing a state here evens the stacks.
+     */
+  yyssp++;
+
+ yysetstate:
+  *yyssp = yystate;
+
+  if (yyss + yystacksize - 1 <= yyssp)
+    {
+      /* Get the current used size of the three stacks, in elements.  */
+      YYSIZE_T yysize = yyssp - yyss + 1;
+
+#ifdef yyoverflow
+      {
+	/* Give user a chance to reallocate the stack. Use copies of
+	   these so that the &'s don't force the real ones into
+	   memory.  */
+	YYSTYPE *yyvs1 = yyvs;
+	short int *yyss1 = yyss;
+
+
+	/* Each stack pointer address is followed by the size of the
+	   data in use in that stack, in bytes.  This used to be a
+	   conditional around just the two extra args, but that might
+	   be undefined if yyoverflow is a macro.  */
+	yyoverflow ("parser stack overflow",
+		    &yyss1, yysize * sizeof (*yyssp),
+		    &yyvs1, yysize * sizeof (*yyvsp),
+
+		    &yystacksize);
+
+	yyss = yyss1;
+	yyvs = yyvs1;
+      }
+#else /* no yyoverflow */
+# ifndef YYSTACK_RELOCATE
+      goto yyoverflowlab;
+# else
+      /* Extend the stack our own way.  */
+      if (YYMAXDEPTH <= yystacksize)
+	goto yyoverflowlab;
+      yystacksize *= 2;
+      if (YYMAXDEPTH < yystacksize)
+	yystacksize = YYMAXDEPTH;
+
+      {
+	short int *yyss1 = yyss;
+	union yyalloc *yyptr =
+	  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
+	if (! yyptr)
+	  goto yyoverflowlab;
+	YYSTACK_RELOCATE (yyss);
+	YYSTACK_RELOCATE (yyvs);
+
+#  undef YYSTACK_RELOCATE
+	if (yyss1 != yyssa)
+	  YYSTACK_FREE (yyss1);
+      }
+# endif
+#endif /* no yyoverflow */
+
+      yyssp = yyss + yysize - 1;
+      yyvsp = yyvs + yysize - 1;
+
+
+      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
+		  (unsigned long int) yystacksize));
+
+      if (yyss + yystacksize - 1 <= yyssp)
+	YYABORT;
+    }
+
+  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
+
+  goto yybackup;
+
+/*-----------.
+| yybackup.  |
+`-----------*/
+yybackup:
+
+/* Do appropriate processing given the current state.  */
+/* Read a lookahead token if we need one and don't already have one.  */
+/* yyresume: */
+
+  /* First try to decide what to do without reference to lookahead token.  */
+
+  yyn = yypact[yystate];
+  if (yyn == YYPACT_NINF)
+    goto yydefault;
+
+  /* Not known => get a lookahead token if don't already have one.  */
+
+  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
+  if (yychar == YYEMPTY)
+    {
+      YYDPRINTF ((stderr, "Reading a token: "));
+      yychar = YYLEX;
+    }
+
+  if (yychar <= YYEOF)
+    {
+      yychar = yytoken = YYEOF;
+      YYDPRINTF ((stderr, "Now at end of input.\n"));
+    }
+  else
+    {
+      yytoken = YYTRANSLATE (yychar);
+      YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);
+    }
+
+  /* If the proper action on seeing token YYTOKEN is to reduce or to
+     detect an error, take that action.  */
+  yyn += yytoken;
+  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
+    goto yydefault;
+  yyn = yytable[yyn];
+  if (yyn <= 0)
+    {
+      if (yyn == 0 || yyn == YYTABLE_NINF)
+	goto yyerrlab;
+      yyn = -yyn;
+      goto yyreduce;
+    }
+
+  if (yyn == YYFINAL)
+    YYACCEPT;
+
+  /* Shift the lookahead token.  */
+  YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));
+
+  /* Discard the token being shifted unless it is eof.  */
+  if (yychar != YYEOF)
+    yychar = YYEMPTY;
+
+  *++yyvsp = yylval;
+
+
+  /* Count tokens shifted since error; after three, turn off error
+     status.  */
+  if (yyerrstatus)
+    yyerrstatus--;
+
+  yystate = yyn;
+  goto yynewstate;
+
+
+/*-----------------------------------------------------------.
+| yydefault -- do the default action for the current state.  |
+`-----------------------------------------------------------*/
+yydefault:
+  yyn = yydefact[yystate];
+  if (yyn == 0)
+    goto yyerrlab;
+  goto yyreduce;
+
+
+/*-----------------------------.
+| yyreduce -- Do a reduction.  |
+`-----------------------------*/
+yyreduce:
+  /* yyn is the number of a rule to reduce with.  */
+  yylen = yyr2[yyn];
+
+  /* If YYLEN is nonzero, implement the default value of the action:
+     `$$ = $1'.
+
+     Otherwise, the following line sets YYVAL to garbage.
+     This behavior is undocumented and Bison
+     users should not rely upon it.  Assigning to YYVAL
+     unconditionally makes the parser a bit smaller, and it avoids a
+     GCC warning that YYVAL may be used uninitialized.  */
+  yyval = yyvsp[1-yylen];
+
+
+  YY_REDUCE_PRINT (yyn);
+  switch (yyn)
+    {
+        case 6:
+
+    {
+        CSSParser *p = static_cast<CSSParser *>(parser);
+	p->rule = yyvsp[-2].rule;
+    ;}
+    break;
+
+  case 7:
+
+    {
+	/* can be empty */
+    ;}
+    break;
+
+  case 8:
+
+    {
+	CSSParser *p = static_cast<CSSParser *>(parser);
+	if ( yyvsp[-1].valueList ) {
+	    p->valueList = yyvsp[-1].valueList;
+#ifdef CSS_DEBUG
+	    kdDebug( 6080 ) << "   got property for " << p->id <<
+		(p->important?" important":"")<< endl;
+	    bool ok =
+#endif
+		p->parseValue( p->id, p->important );
+#ifdef CSS_DEBUG
+	    if ( !ok )
+		kdDebug( 6080 ) << "     couldn't parse value!" << endl;
+#endif
+	}
+#ifdef CSS_DEBUG
+	else
+	    kdDebug( 6080 ) << "     no value found!" << endl;
+#endif
+	delete p->valueList;
+	p->valueList = 0;
+    ;}
+    break;
+
+  case 15:
+
+    {
+#ifdef CSS_DEBUG
+     kdDebug( 6080 ) << "charset rule: " << qString(yyvsp[-2].string) << endl;
+#endif
+ ;}
+    break;
+
+  case 19:
+
+    {
+     CSSParser *p = static_cast<CSSParser *>(parser);
+     if ( yyvsp[-1].rule && p->styleElement && p->styleElement->isCSSStyleSheet() ) {
+	 p->styleElement->append( yyvsp[-1].rule );
+     } else {
+	 delete yyvsp[-1].rule;
+     }
+ ;}
+    break;
+
+  case 20:
+
+    {
+#ifdef CSS_DEBUG
+	kdDebug( 6080 ) << "@import: " << qString(yyvsp[-3].string) << endl;
+#endif
+	CSSParser *p = static_cast<CSSParser *>(parser);
+	if ( yyvsp[-1].mediaList && p->styleElement && p->styleElement->isCSSStyleSheet() )
+	    yyval.rule = new CSSImportRuleImpl( p->styleElement, domString(yyvsp[-3].string), yyvsp[-1].mediaList );
+	else
+	    yyval.rule = 0;
+    ;}
+    break;
+
+  case 21:
+
+    {
+        yyval.rule = 0;
+    ;}
+    break;
+
+  case 22:
+
+    {
+        yyval.rule = 0;
+    ;}
+    break;
+
+  case 25:
+
+    {
+#ifdef CSS_DEBUG
+    kdDebug( 6080 ) << "@namespace: " << qString(yyvsp[-2].string) << endl;
+#endif
+      CSSParser *p = static_cast<CSSParser *>(parser);
+    if (p->styleElement && p->styleElement->isCSSStyleSheet())
+        static_cast<CSSStyleSheetImpl*>(p->styleElement)->addNamespace(p, domString(yyvsp[-3].string), domString(yyvsp[-2].string));
+ ;}
+    break;
+
+  case 28:
+
+    { yyval.string.string = 0; ;}
+    break;
+
+  case 29:
+
+    { yyval.string = yyvsp[-1].string; ;}
+    break;
+
+  case 31:
+
+    {
+     CSSParser *p = static_cast<CSSParser *>(parser);
+     if ( yyvsp[-1].rule && p->styleElement && p->styleElement->isCSSStyleSheet() ) {
+	 p->styleElement->append( yyvsp[-1].rule );
+     } else {
+	 delete yyvsp[-1].rule;
+     }
+ ;}
+    break;
+
+  case 38:
+
+    { delete yyvsp[-1].rule; yyval.rule = 0; ;}
+    break;
+
+  case 41:
+
+    {
+	yyval.mediaList = new MediaListImpl();
+    ;}
+    break;
+
+  case 43:
+
+    {
+	yyval.mediaList = new MediaListImpl();
+	yyval.mediaList->appendMedium( domString(yyvsp[0].string).lower() );
+    ;}
+    break;
+
+  case 44:
+
+    {
+	yyval.mediaList = yyvsp[-3].mediaList;
+	if (yyval.mediaList)
+	    yyval.mediaList->appendMedium( domString(yyvsp[0].string).lower() );
+    ;}
+    break;
+
+  case 45:
+
+    {
+       delete yyvsp[-1].mediaList;
+       yyval.mediaList = 0;
+    ;}
+    break;
+
+  case 46:
+
+    {
+	CSSParser *p = static_cast<CSSParser *>(parser);
+	if ( yyvsp[-4].mediaList && yyvsp[-1].ruleList &&
+	     p->styleElement && p->styleElement->isCSSStyleSheet() ) {
+	    yyval.rule = new CSSMediaRuleImpl( static_cast<CSSStyleSheetImpl*>(p->styleElement), yyvsp[-4].mediaList, yyvsp[-1].ruleList );
+	} else {
+	    yyval.rule = 0;
+	    delete yyvsp[-4].mediaList;
+	    delete yyvsp[-1].ruleList;
+	}
+    ;}
+    break;
+
+  case 47:
+
+    { yyval.ruleList = 0; ;}
+    break;
+
+  case 48:
+
+    {
+      yyval.ruleList = yyvsp[-2].ruleList;
+      if ( yyvsp[-1].rule ) {
+	  if ( !yyval.ruleList ) yyval.ruleList = new CSSRuleListImpl();
+	  yyval.ruleList->append( yyvsp[-1].rule );
+      }
+  ;}
+    break;
+
+  case 49:
+
+    {
+      yyval.string = yyvsp[-1].string;
+  ;}
+    break;
+
+  case 50:
+
+    {
+      yyval.rule = 0;
+    ;}
+    break;
+
+  case 51:
+
+    {
+      yyval.rule = 0;
+    ;}
+    break;
+
+  case 52:
+
+    {
+      yyval.rule = 0;
+    ;}
+    break;
+
+  case 53:
+
+    {
+      yyval.rule = 0;
+    ;}
+    break;
+
+  case 54:
+
+    { yyval.relation = CSSSelector::DirectAdjacent; ;}
+    break;
+
+  case 55:
+
+    { yyval.relation = CSSSelector::IndirectAdjacent; ;}
+    break;
+
+  case 56:
+
+    { yyval.relation = CSSSelector::Child; ;}
+    break;
+
+  case 57:
+
+    { yyval.relation = CSSSelector::Descendant; ;}
+    break;
+
+  case 58:
+
+    { yyval.val = -1; ;}
+    break;
+
+  case 59:
+
+    { yyval.val = 1; ;}
+    break;
+
+  case 60:
+
+    {
+#ifdef CSS_DEBUG
+	kdDebug( 6080 ) << "got ruleset" << endl << "  selector:" << endl;
+#endif
+	CSSParser *p = static_cast<CSSParser *>(parser);
+	if ( yyvsp[-1].selectorList && yyvsp[0].ok && p->numParsedProperties ) {
+	    CSSStyleRuleImpl *rule = new CSSStyleRuleImpl( p->styleElement );
+	    CSSStyleDeclarationImpl *decl = p->createStyleDeclaration( rule );
+	    rule->setSelector( yyvsp[-1].selectorList );
+	    rule->setDeclaration(decl);
+	    yyval.rule = rule;
+	} else {
+	    yyval.rule = 0;
+	    delete yyvsp[-1].selectorList;
+	    p->clearProperties();
+	}
+    ;}
+    break;
+
+  case 61:
+
+    {
+	if ( yyvsp[0].selector ) {
+	    yyval.selectorList = new TQPtrList<CSSSelector>;
+            yyval.selectorList->setAutoDelete( true );
+#ifdef CSS_DEBUG
+	    kdDebug( 6080 ) << "   got simple selector:" << endl;
+	    yyvsp[0].selector->print();
+#endif
+	    yyval.selectorList->append( yyvsp[0].selector );
+	    tdehtml::CSSStyleSelector::precomputeAttributeDependencies(static_cast<CSSParser *>(parser)->document(), yyvsp[0].selector);
+	} else {
+	    yyval.selectorList = 0;
+	}
+    ;}
+    break;
+
+  case 62:
+
+    {
+	if ( yyvsp[-3].selectorList && yyvsp[0].selector ) {
+	    yyval.selectorList = yyvsp[-3].selectorList;
+	    yyval.selectorList->append( yyvsp[0].selector );
+	    tdehtml::CSSStyleSelector::precomputeAttributeDependencies(static_cast<CSSParser *>(parser)->document(), yyvsp[0].selector);
+#ifdef CSS_DEBUG
+	    kdDebug( 6080 ) << "   got simple selector:" << endl;
+	    yyvsp[0].selector->print();
+#endif
+	} else {
+	    delete yyvsp[-3].selectorList;
+	    delete yyvsp[0].selector;
+	    yyval.selectorList = 0;
+	}
+    ;}
+    break;
+
+  case 63:
+
+    {
+	delete yyvsp[-1].selectorList;
+	yyval.selectorList = 0;
+    ;}
+    break;
+
+  case 64:
+
+    {
+	yyval.selector = yyvsp[0].selector;
+    ;}
+    break;
+
+  case 65:
+
+    {
+	if ( !yyvsp[-2].selector || !yyvsp[0].selector ) {
+	    delete yyvsp[-2].selector;
+	    delete yyvsp[0].selector;
+	    yyval.selector = 0;
+	} else {
+	    yyval.selector = yyvsp[0].selector;
+	    CSSSelector *end = yyvsp[0].selector;
+	    while( end->tagHistory )
+		end = end->tagHistory;
+	    end->relation = yyvsp[-1].relation;
+	    end->tagHistory = yyvsp[-2].selector;
+	}
+    ;}
+    break;
+
+  case 66:
+
+    {
+	delete yyvsp[-1].selector;
+	yyval.selector = 0;
+    ;}
+    break;
+
+  case 67:
+
+    { yyval.string.string = 0; yyval.string.length = 0; ;}
+    break;
+
+  case 68:
+
+    { static unsigned short star = '*'; yyval.string.string = &star; yyval.string.length = 1; ;}
+    break;
+
+  case 69:
+
+    { yyval.string = yyvsp[-1].string; ;}
+    break;
+
+  case 70:
+
+    {
+	yyval.selector = new CSSSelector();
+	yyval.selector->tag = yyvsp[-1].element;
+    ;}
+    break;
+
+  case 71:
+
+    {
+	yyval.selector = yyvsp[-1].selector;
+        if ( yyval.selector )
+	    yyval.selector->tag = yyvsp[-2].element;
+    ;}
+    break;
+
+  case 72:
+
+    {
+	yyval.selector = yyvsp[-1].selector;
+        if ( yyval.selector )
+            yyval.selector->tag = makeId(static_cast<CSSParser*>(parser)->defaultNamespace(), anyLocalName);
+    ;}
+    break;
+
+  case 73:
+
+    {
+        yyval.selector = new CSSSelector();
+        yyval.selector->tag = yyvsp[-1].element;
+	CSSParser *p = static_cast<CSSParser *>(parser);
+        if (p->styleElement && p->styleElement->isCSSStyleSheet())
+            static_cast<CSSStyleSheetImpl*>(p->styleElement)->determineNamespace(yyval.selector->tag, domString(yyvsp[-2].string));
+    ;}
+    break;
+
+  case 74:
+
+    {
+        yyval.selector = yyvsp[-1].selector;
+        if (yyval.selector) {
+            yyval.selector->tag = yyvsp[-2].element;
+            CSSParser *p = static_cast<CSSParser *>(parser);
+            if (p->styleElement && p->styleElement->isCSSStyleSheet())
+                static_cast<CSSStyleSheetImpl*>(p->styleElement)->determineNamespace(yyval.selector->tag, domString(yyvsp[-3].string));
+        }
+    ;}
+    break;
+
+  case 75:
+
+    {
+        yyval.selector = yyvsp[-1].selector;
+        if (yyval.selector) {
+            yyval.selector->tag = makeId(anyNamespace, anyLocalName);
+            CSSParser *p = static_cast<CSSParser *>(parser);
+            if (p->styleElement && p->styleElement->isCSSStyleSheet())
+                static_cast<CSSStyleSheetImpl*>(p->styleElement)->determineNamespace(yyval.selector->tag, domString(yyvsp[-2].string));
+        }
+    ;}
+    break;
+
+  case 76:
+
+    {
+	CSSParser *p = static_cast<CSSParser *>(parser);
+	DOM::DocumentImpl *doc = p->document();
+	TQString tag = qString(yyvsp[0].string);
+	if ( doc ) {
+	    if (doc->isHTMLDocument())
+		tag = tag.lower();
+	    const DOMString dtag(tag);
+            yyval.element = makeId(p->defaultNamespace(), doc->getId(NodeImpl::ElementId, dtag.implementation(), false, true));
+	} else {
+	    yyval.element = makeId(p->defaultNamespace(), tdehtml::getTagID(tag.lower().ascii(), tag.length()));
+	    // this case should never happen - only when loading
+	    // the default stylesheet - which must not contain unknown tags
+// 	    assert($$ != 0);
+	}
+    ;}
+    break;
+
+  case 77:
+
+    {
+	yyval.element = makeId(static_cast<CSSParser*>(parser)->defaultNamespace(), anyLocalName);
+    ;}
+    break;
+
+  case 78:
+
+    {
+	yyval.selector = yyvsp[0].selector;
+	yyval.selector->nonCSSHint = static_cast<CSSParser *>(parser)->nonCSSHint;
+    ;}
+    break;
+
+  case 79:
+
+    {
+	yyval.selector = yyvsp[-1].selector;
+	if ( yyval.selector ) {
+            CSSSelector *end = yyvsp[-1].selector;
+            while( end->tagHistory )
+                end = end->tagHistory;
+            end->relation = CSSSelector::SubSelector;
+            end->tagHistory = yyvsp[0].selector;
+	}
+    ;}
+    break;
+
+  case 80:
+
+    {
+	delete yyvsp[-1].selector;
+	yyval.selector = 0;
+    ;}
+    break;
+
+  case 81:
+
+    {
+	yyval.selector = new CSSSelector();
+	yyval.selector->match = CSSSelector::Id;
+	yyval.selector->attr = ATTR_ID;
+	yyval.selector->value = domString(yyvsp[0].string);
+    ;}
+    break;
+
+  case 85:
+
+    {
+	yyval.selector = new CSSSelector();
+	yyval.selector->match = CSSSelector::Class;
+	yyval.selector->attr = ATTR_CLASS;
+	yyval.selector->value = domString(yyvsp[0].string);
+    ;}
+    break;
+
+  case 86:
+
+    {
+	CSSParser *p = static_cast<CSSParser *>(parser);
+	DOM::DocumentImpl *doc = p->document();
+
+	TQString attr = qString(yyvsp[-1].string);
+	if ( doc ) {
+	    if (doc->isHTMLDocument())
+		attr = attr.lower();
+	    const DOMString dattr(attr);
+#ifdef APPLE_CHANGES
+            yyval.attribute = doc->attrId(0, dattr.implementation(), false);
+#else
+	    yyval.attribute = doc->getId(NodeImpl::AttributeId, dattr.implementation(), false, true);
+#endif
+	} else {
+	    yyval.attribute = tdehtml::getAttrID(attr.lower().ascii(), attr.length());
+	    // this case should never happen - only when loading
+	    // the default stylesheet - which must not contain unknown attributes
+	    assert(yyval.attribute != 0);
+	    }
+    ;}
+    break;
+
+  case 87:
+
+    {
+	yyval.selector = new CSSSelector();
+	yyval.selector->attr = yyvsp[-1].attribute;
+	yyval.selector->match = CSSSelector::Set;
+    ;}
+    break;
+
+  case 88:
+
+    {
+	yyval.selector = new CSSSelector();
+	yyval.selector->attr = yyvsp[-5].attribute;
+	yyval.selector->match = yyvsp[-4].match;
+	yyval.selector->value = domString(yyvsp[-2].string);
+    ;}
+    break;
+
+  case 89:
+
+    {
+        yyval.selector = new CSSSelector();
+        yyval.selector->attr = yyvsp[-1].attribute;
+        yyval.selector->match = CSSSelector::Set;
+        CSSParser *p = static_cast<CSSParser *>(parser);
+        if (p->styleElement && p->styleElement->isCSSStyleSheet())
+            static_cast<CSSStyleSheetImpl*>(p->styleElement)->determineNamespace(yyval.selector->attr, domString(yyvsp[-2].string));
+    ;}
+    break;
+
+  case 90:
+
+    {
+        yyval.selector = new CSSSelector();
+        yyval.selector->attr = yyvsp[-5].attribute;
+        yyval.selector->match = (CSSSelector::Match)yyvsp[-4].match;
+        yyval.selector->value = domString(yyvsp[-2].string);
+        CSSParser *p = static_cast<CSSParser *>(parser);
+        if (p->styleElement && p->styleElement->isCSSStyleSheet())
+            static_cast<CSSStyleSheetImpl*>(p->styleElement)->determineNamespace(yyval.selector->attr, domString(yyvsp[-6].string));
+   ;}
+    break;
+
+  case 91:
+
+    {
+	yyval.match = CSSSelector::Exact;
+    ;}
+    break;
+
+  case 92:
+
+    {
+	yyval.match = CSSSelector::List;
+    ;}
+    break;
+
+  case 93:
+
+    {
+	yyval.match = CSSSelector::Hyphen;
+    ;}
+    break;
+
+  case 94:
+
+    {
+	yyval.match = CSSSelector::Begin;
+    ;}
+    break;
+
+  case 95:
+
+    {
+	yyval.match = CSSSelector::End;
+    ;}
+    break;
+
+  case 96:
+
+    {
+	yyval.match = CSSSelector::Contain;
+    ;}
+    break;
+
+  case 99:
+
+    {
+	yyval.selector = new CSSSelector();
+	yyval.selector->match = CSSSelector::PseudoClass;
+	yyval.selector->value = domString(yyvsp[0].string);
+    ;}
+    break;
+
+  case 100:
+
+    {
+	yyval.selector = new CSSSelector();
+	yyval.selector->match = CSSSelector::PseudoElement;
+        yyval.selector->value = domString(yyvsp[0].string);
+    ;}
+    break;
+
+  case 101:
+
+    {
+        yyval.selector = new CSSSelector();
+        yyval.selector->match = CSSSelector::PseudoClass;
+        yyval.selector->string_arg = domString(yyvsp[-1].string);
+        yyval.selector->value = domString(yyvsp[-2].string);
+    ;}
+    break;
+
+  case 102:
+
+    {
+        yyval.selector = new CSSSelector();
+        yyval.selector->match = CSSSelector::PseudoClass;
+        yyval.selector->string_arg = TQString::number(yyvsp[-1].val);
+        yyval.selector->value = domString(yyvsp[-2].string);
+    ;}
+    break;
+
+  case 103:
+
+    {
+        yyval.selector = new CSSSelector();
+        yyval.selector->match = CSSSelector::PseudoClass;
+        yyval.selector->string_arg = domString(yyvsp[-1].string);
+        yyval.selector->value = domString(yyvsp[-2].string);
+    ;}
+    break;
+
+  case 104:
+
+    {
+        yyval.selector = new CSSSelector();
+        yyval.selector->match = CSSSelector::PseudoClass;
+        yyval.selector->string_arg = domString(yyvsp[-1].string);
+        yyval.selector->value = domString(yyvsp[-2].string);
+    ;}
+    break;
+
+  case 105:
+
+    {
+        yyval.selector = new CSSSelector();
+        yyval.selector->match = CSSSelector::PseudoClass;
+        yyval.selector->simpleSelector = yyvsp[-1].selector;
+        yyval.selector->value = domString(yyvsp[-3].string);
+    ;}
+    break;
+
+  case 106:
+
+    {
+	yyval.ok = yyvsp[-1].ok;
+    ;}
+    break;
+
+  case 107:
+
+    {
+	yyval.ok = false;
+    ;}
+    break;
+
+  case 108:
+
+    {
+	yyval.ok = yyvsp[-1].ok;
+    ;}
+    break;
+
+  case 109:
+
+    {
+	yyval.ok = yyvsp[-2].ok;
+	if ( yyvsp[-1].ok )
+	    yyval.ok = yyvsp[-1].ok;
+    ;}
+    break;
+
+  case 110:
+
+    {
+	yyval.ok = yyvsp[-2].ok;
+    ;}
+    break;
+
+  case 111:
+
+    {
+	yyval.ok = yyvsp[-2].ok;
+    ;}
+    break;
+
+  case 112:
+
+    {
+        yyval.ok = false;
+    ;}
+    break;
+
+  case 113:
+
+    {
+	yyval.ok = yyvsp[-3].ok;
+	if ( yyvsp[-2].ok )
+	    yyval.ok = yyvsp[-2].ok;
+    ;}
+    break;
+
+  case 114:
+
+    {
+        yyval.ok = yyvsp[-3].ok;
+    ;}
+    break;
+
+  case 115:
+
+    {
+	yyval.ok = false;
+	CSSParser *p = static_cast<CSSParser *>(parser);
+	if ( yyvsp[-4].prop_id && yyvsp[-1].valueList ) {
+	    p->valueList = yyvsp[-1].valueList;
+#ifdef CSS_DEBUG
+	    kdDebug( 6080 ) << "   got property: " << yyvsp[-4].prop_id <<
+		(yyvsp[0].b?" important":"")<< endl;
+#endif
+	        bool ok = p->parseValue( yyvsp[-4].prop_id, yyvsp[0].b );
+                if ( ok )
+		    yyval.ok = ok;
+#ifdef CSS_DEBUG
+	        else
+		    kdDebug( 6080 ) << "     couldn't parse value!" << endl;
+#endif
+	} else {
+            delete yyvsp[-1].valueList;
+        }
+	delete p->valueList;
+	p->valueList = 0;
+    ;}
+    break;
+
+  case 116:
+
+    {
+        yyval.ok = false;
+    ;}
+    break;
+
+  case 117:
+
+    {
+	TQString str = qString(yyvsp[-1].string);
+	yyval.prop_id = getPropertyID( str.lower().latin1(), str.length() );
+    ;}
+    break;
+
+  case 118:
+
+    { yyval.b = true; ;}
+    break;
+
+  case 119:
+
+    { yyval.b = false; ;}
+    break;
+
+  case 120:
+
+    {
+	yyval.valueList = new ValueList;
+	yyval.valueList->addValue( yyvsp[0].value );
+    ;}
+    break;
+
+  case 121:
+
+    {
+	yyval.valueList = yyvsp[-2].valueList;
+	if ( yyval.valueList ) {
+	    if ( yyvsp[-1].tok ) {
+		Value v;
+		v.id = 0;
+		v.unit = Value::Operator;
+		v.iValue = yyvsp[-1].tok;
+		yyval.valueList->addValue( v );
+	    }
+	    yyval.valueList->addValue( yyvsp[0].value );
+	}
+    ;}
+    break;
+
+  case 122:
+
+    {
+	yyval.tok = '/';
+    ;}
+    break;
+
+  case 123:
+
+    {
+	yyval.tok = ',';
+    ;}
+    break;
+
+  case 124:
+
+    {
+        yyval.tok = 0;
+  ;}
+    break;
+
+  case 125:
+
+    { yyval.value = yyvsp[0].value; ;}
+    break;
+
+  case 126:
+
+    { yyval.value = yyvsp[0].value; yyval.value.fValue *= yyvsp[-1].val; ;}
+    break;
+
+  case 127:
+
+    { yyval.value.id = 0; yyval.value.string = yyvsp[-1].string; yyval.value.unit = CSSPrimitiveValue::CSS_DIMENSION; ;}
+    break;
+
+  case 128:
+
+    { yyval.value.id = 0; yyval.value.string = yyvsp[-1].string; yyval.value.unit = CSSPrimitiveValue::CSS_STRING; ;}
+    break;
+
+  case 129:
+
+    {
+      TQString str = qString( yyvsp[-1].string );
+      yyval.value.id = getValueID( str.lower().latin1(), str.length() );
+      yyval.value.unit = CSSPrimitiveValue::CSS_IDENT;
+      yyval.value.string = yyvsp[-1].string;
+  ;}
+    break;
+
+  case 130:
+
+    { yyval.value.id = 0; yyval.value.string = yyvsp[-1].string; yyval.value.unit = CSSPrimitiveValue::CSS_URI; ;}
+    break;
+
+  case 131:
+
+    { yyval.value.id = 0; yyval.value.iValue = 0; yyval.value.unit = CSSPrimitiveValue::CSS_UNKNOWN;/* ### */ ;}
+    break;
+
+  case 132:
+
+    { yyval.value.id = 0; yyval.value.string = yyvsp[0].string; yyval.value.unit = CSSPrimitiveValue::CSS_RGBCOLOR; ;}
+    break;
+
+  case 133:
+
+    {
+      yyval.value = yyvsp[0].value;
+  ;}
+    break;
+
+  case 134:
+
+    { yyval.value.id = 0; yyval.value.isInt = true; yyval.value.fValue = yyvsp[-1].val; yyval.value.unit = CSSPrimitiveValue::CSS_NUMBER; ;}
+    break;
+
+  case 135:
+
+    { yyval.value.id = 0; yyval.value.isInt = false; yyval.value.fValue = yyvsp[-1].val; yyval.value.unit = CSSPrimitiveValue::CSS_NUMBER; ;}
+    break;
+
+  case 136:
+
+    { yyval.value.id = 0; yyval.value.fValue = yyvsp[-1].val; yyval.value.unit = CSSPrimitiveValue::CSS_PERCENTAGE; ;}
+    break;
+
+  case 137:
+
+    { yyval.value.id = 0; yyval.value.fValue = yyvsp[-1].val; yyval.value.unit = CSSPrimitiveValue::CSS_PX; ;}
+    break;
+
+  case 138:
+
+    { yyval.value.id = 0; yyval.value.fValue = yyvsp[-1].val; yyval.value.unit = CSSPrimitiveValue::CSS_CM; ;}
+    break;
+
+  case 139:
+
+    { yyval.value.id = 0; yyval.value.fValue = yyvsp[-1].val; yyval.value.unit = CSSPrimitiveValue::CSS_MM; ;}
+    break;
+
+  case 140:
+
+    { yyval.value.id = 0; yyval.value.fValue = yyvsp[-1].val; yyval.value.unit = CSSPrimitiveValue::CSS_IN; ;}
+    break;
+
+  case 141:
+
+    { yyval.value.id = 0; yyval.value.fValue = yyvsp[-1].val; yyval.value.unit = CSSPrimitiveValue::CSS_PT; ;}
+    break;
+
+  case 142:
+
+    { yyval.value.id = 0; yyval.value.fValue = yyvsp[-1].val; yyval.value.unit = CSSPrimitiveValue::CSS_PC; ;}
+    break;
+
+  case 143:
+
+    { yyval.value.id = 0; yyval.value.fValue = yyvsp[-1].val; yyval.value.unit = CSSPrimitiveValue::CSS_DEG; ;}
+    break;
+
+  case 144:
+
+    { yyval.value.id = 0; yyval.value.fValue = yyvsp[-1].val; yyval.value.unit = CSSPrimitiveValue::CSS_RAD; ;}
+    break;
+
+  case 145:
+
+    { yyval.value.id = 0; yyval.value.fValue = yyvsp[-1].val; yyval.value.unit = CSSPrimitiveValue::CSS_GRAD; ;}
+    break;
+
+  case 146:
+
+    { yyval.value.id = 0; yyval.value.fValue = yyvsp[-1].val; yyval.value.unit = CSSPrimitiveValue::CSS_MS; ;}
+    break;
+
+  case 147:
+
+    { yyval.value.id = 0; yyval.value.fValue = yyvsp[-1].val; yyval.value.unit = CSSPrimitiveValue::CSS_S; ;}
+    break;
+
+  case 148:
+
+    { yyval.value.id = 0; yyval.value.fValue = yyvsp[-1].val; yyval.value.unit = CSSPrimitiveValue::CSS_HZ; ;}
+    break;
+
+  case 149:
+
+    { yyval.value.id = 0; yyval.value.fValue = yyvsp[-1].val; yyval.value.unit = CSSPrimitiveValue::CSS_KHZ; ;}
+    break;
+
+  case 150:
+
+    { yyval.value.id = 0; yyval.value.fValue = yyvsp[-1].val; yyval.value.unit = CSSPrimitiveValue::CSS_EMS; ;}
+    break;
+
+  case 151:
+
+    { yyval.value.id = 0; yyval.value.fValue = yyvsp[-1].val; yyval.value.unit = Value::Q_EMS; ;}
+    break;
+
+  case 152:
+
+    { yyval.value.id = 0; yyval.value.fValue = yyvsp[-1].val; yyval.value.unit = CSSPrimitiveValue::CSS_EXS; ;}
+    break;
+
+  case 153:
+
+    {
+      Function *f = new Function;
+      f->name = yyvsp[-4].string;
+      f->args = yyvsp[-2].valueList;
+      yyval.value.id = 0;
+      yyval.value.unit = Value::Function;
+      yyval.value.function = f;
+  ;}
+    break;
+
+  case 154:
+
+    {
+      Function *f = new Function;
+      f->name = yyvsp[-2].string;
+      f->args = 0;
+      yyval.value.id = 0;
+      yyval.value.unit = Value::Function;
+      yyval.value.function = f;
+  ;}
+    break;
+
+  case 155:
+
+    { yyval.string = yyvsp[-1].string; ;}
+    break;
+
+  case 156:
+
+    {
+	yyval.rule = 0;
+#ifdef CSS_DEBUG
+	kdDebug( 6080 ) << "skipped invalid @-rule" << endl;
+#endif
+    ;}
+    break;
+
+  case 157:
+
+    {
+	yyval.rule = 0;
+#ifdef CSS_DEBUG
+	kdDebug( 6080 ) << "skipped invalid @-rule" << endl;
+#endif
+    ;}
+    break;
+
+  case 158:
+
+    {
+	yyval.rule = 0;
+#ifdef CSS_DEBUG
+	kdDebug( 6080 ) << "skipped invalid rule" << endl;
+#endif
+    ;}
+    break;
+
+
+    }
+
+/* Line 1010 of yacc.c.  */
+
+
+  yyvsp -= yylen;
+  yyssp -= yylen;
+
+
+  YY_STACK_PRINT (yyss, yyssp);
+
+  *++yyvsp = yyval;
+
+
+  /* Now `shift' the result of the reduction.  Determine what state
+     that goes to, based on the state we popped back to and the rule
+     number reduced by.  */
+
+  yyn = yyr1[yyn];
+
+  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
+  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
+    yystate = yytable[yystate];
+  else
+    yystate = yydefgoto[yyn - YYNTOKENS];
+
+  goto yynewstate;
+
+
+/*------------------------------------.
+| yyerrlab -- here on detecting error |
+`------------------------------------*/
+yyerrlab:
+  /* If not already recovering from an error, report this error.  */
+  if (!yyerrstatus)
+    {
+      ++yynerrs;
+#if YYERROR_VERBOSE
+      yyn = yypact[yystate];
+
+      if (YYPACT_NINF < yyn && yyn < YYLAST)
+	{
+	  YYSIZE_T yysize = 0;
+	  int yytype = YYTRANSLATE (yychar);
+	  const char* yyprefix;
+	  char *yymsg;
+	  int yyx;
+
+	  /* Start YYX at -YYN if negative to avoid negative indexes in
+	     YYCHECK.  */
+	  int yyxbegin = yyn < 0 ? -yyn : 0;
+
+	  /* Stay within bounds of both yycheck and yytname.  */
+	  int yychecklim = YYLAST - yyn;
+	  int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
+	  int yycount = 0;
+
+	  yyprefix = ", expecting ";
+	  for (yyx = yyxbegin; yyx < yyxend; ++yyx)
+	    if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
+	      {
+		yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]);
+		yycount += 1;
+		if (yycount == 5)
+		  {
+		    yysize = 0;
+		    break;
+		  }
+	      }
+	  yysize += (sizeof ("syntax error, unexpected ")
+		     + yystrlen (yytname[yytype]));
+	  yymsg = (char *) YYSTACK_ALLOC (yysize);
+	  if (yymsg != 0)
+	    {
+	      char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
+	      yyp = yystpcpy (yyp, yytname[yytype]);
+
+	      if (yycount < 5)
+		{
+		  yyprefix = ", expecting ";
+		  for (yyx = yyxbegin; yyx < yyxend; ++yyx)
+		    if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
+		      {
+			yyp = yystpcpy (yyp, yyprefix);
+			yyp = yystpcpy (yyp, yytname[yyx]);
+			yyprefix = " or ";
+		      }
+		}
+	      yyerror (yymsg);
+	      YYSTACK_FREE (yymsg);
+	    }
+	  else
+	    yyerror ("syntax error; also virtual memory exhausted");
+	}
+      else
+#endif /* YYERROR_VERBOSE */
+	yyerror ("syntax error");
+    }
+
+
+
+  if (yyerrstatus == 3)
+    {
+      /* If just tried and failed to reuse lookahead token after an
+	 error, discard it.  */
+
+      if (yychar <= YYEOF)
+        {
+          /* If at end of input, pop the error token,
+	     then the rest of the stack, then return failure.  */
+	  if (yychar == YYEOF)
+	     for (;;)
+	       {
+		 YYPOPSTACK;
+		 if (yyssp == yyss)
+		   YYABORT;
+		 YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
+		 yydestruct (yystos[*yyssp], yyvsp);
+	       }
+        }
+      else
+	{
+	  YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
+	  yydestruct (yytoken, &yylval);
+	  yychar = YYEMPTY;
+
+	}
+    }
+
+  /* Else will try to reuse lookahead token after shifting the error
+     token.  */
+  goto yyerrlab1;
+
+
+/*---------------------------------------------------.
+| yyerrorlab -- error raised explicitly by YYERROR.  |
+`---------------------------------------------------*/
+yyerrorlab:
+
+#ifdef __GNUC__
+  /* Pacify GCC when the user code never invokes YYERROR and the label
+     yyerrorlab therefore never appears in user code.  */
+  if (0)
+     goto yyerrorlab;
+#endif
+
+  yyvsp -= yylen;
+  yyssp -= yylen;
+  yystate = *yyssp;
+  goto yyerrlab1;
+
+
+/*-------------------------------------------------------------.
+| yyerrlab1 -- common code for both syntax error and YYERROR.  |
+`-------------------------------------------------------------*/
+yyerrlab1:
+  yyerrstatus = 3;	/* Each real token shifted decrements this.  */
+
+  for (;;)
+    {
+      yyn = yypact[yystate];
+      if (yyn != YYPACT_NINF)
+	{
+	  yyn += YYTERROR;
+	  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
+	    {
+	      yyn = yytable[yyn];
+	      if (0 < yyn)
+		break;
+	    }
+	}
+
+      /* Pop the current state because it cannot handle the error token.  */
+      if (yyssp == yyss)
+	YYABORT;
+
+      YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
+      yydestruct (yystos[yystate], yyvsp);
+      YYPOPSTACK;
+      yystate = *yyssp;
+      YY_STACK_PRINT (yyss, yyssp);
+    }
+
+  if (yyn == YYFINAL)
+    YYACCEPT;
+
+  YYDPRINTF ((stderr, "Shifting error token, "));
+
+  *++yyvsp = yylval;
+
+
+  yystate = yyn;
+  goto yynewstate;
+
+
+/*-------------------------------------.
+| yyacceptlab -- YYACCEPT comes here.  |
+`-------------------------------------*/
+yyacceptlab:
+  yyresult = 0;
+  goto yyreturn;
+
+/*-----------------------------------.
+| yyabortlab -- YYABORT comes here.  |
+`-----------------------------------*/
+yyabortlab:
+  yyresult = 1;
+  goto yyreturn;
+
+#ifndef yyoverflow
+/*----------------------------------------------.
+| yyoverflowlab -- parser overflow comes here.  |
+`----------------------------------------------*/
+yyoverflowlab:
+  yyerror ("parser stack overflow");
+  yyresult = 2;
+  /* Fall through.  */
+#endif
+
+yyreturn:
+#ifndef yyoverflow
+  if (yyss != yyssa)
+    YYSTACK_FREE (yyss);
+#endif
+  return yyresult;
+}
+
+
+
+
+
+
diff --git a/tdehtml/css/parser.h b/tdehtml/css/parser.h
new file mode 100644
index 000000000..e3375db66
--- /dev/null
+++ b/tdehtml/css/parser.h
@@ -0,0 +1,164 @@
+/* A Bison parser, made by GNU Bison 1.875d.  */
+
+/*  Skeleton parser for Yacc-like parsing with Bison,
+    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2, or (at your option)
+    any later version.
+
+    This program 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 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.
+*/
+
+/* As a special exception, when this file is copied by Bison into a
+   Bison output file, you may use that output file without restriction.
+   This special exception was added by the Free Software Foundation
+   in version 1.24 of Bison.  */
+
+/* Tokens.  */
+#ifndef YYTOKENTYPE
+# define YYTOKENTYPE
+   /* Put the tokens into the symbol table, so that GDB and other debuggers
+      know about them.  */
+   enum yytokentype {
+     UNIMPORTANT_TOK = 258,
+     S = 259,
+     SGML_CD = 260,
+     INCLUDES = 261,
+     DASHMATCH = 262,
+     BEGINSWITH = 263,
+     ENDSWITH = 264,
+     CONTAINS = 265,
+     STRING = 266,
+     IDENT = 267,
+     NTH = 268,
+     HASH = 269,
+     IMPORT_SYM = 270,
+     PAGE_SYM = 271,
+     MEDIA_SYM = 272,
+     FONT_FACE_SYM = 273,
+     CHARSET_SYM = 274,
+     NAMESPACE_SYM = 275,
+     KHTML_RULE_SYM = 276,
+     KHTML_DECLS_SYM = 277,
+     KHTML_VALUE_SYM = 278,
+     IMPORTANT_SYM = 279,
+     QEMS = 280,
+     EMS = 281,
+     EXS = 282,
+     PXS = 283,
+     CMS = 284,
+     MMS = 285,
+     INS = 286,
+     PTS = 287,
+     PCS = 288,
+     DEGS = 289,
+     RADS = 290,
+     GRADS = 291,
+     MSECS = 292,
+     SECS = 293,
+     HERZ = 294,
+     KHERZ = 295,
+     DIMEN = 296,
+     PERCENTAGE = 297,
+     FLOAT = 298,
+     INTEGER = 299,
+     URI = 300,
+     FUNCTION = 301,
+     NOTFUNCTION = 302,
+     UNICODERANGE = 303
+   };
+#endif
+#define UNIMPORTANT_TOK 258
+#define S 259
+#define SGML_CD 260
+#define INCLUDES 261
+#define DASHMATCH 262
+#define BEGINSWITH 263
+#define ENDSWITH 264
+#define CONTAINS 265
+#define STRING 266
+#define IDENT 267
+#define NTH 268
+#define HASH 269
+#define IMPORT_SYM 270
+#define PAGE_SYM 271
+#define MEDIA_SYM 272
+#define FONT_FACE_SYM 273
+#define CHARSET_SYM 274
+#define NAMESPACE_SYM 275
+#define KHTML_RULE_SYM 276
+#define KHTML_DECLS_SYM 277
+#define KHTML_VALUE_SYM 278
+#define IMPORTANT_SYM 279
+#define QEMS 280
+#define EMS 281
+#define EXS 282
+#define PXS 283
+#define CMS 284
+#define MMS 285
+#define INS 286
+#define PTS 287
+#define PCS 288
+#define DEGS 289
+#define RADS 290
+#define GRADS 291
+#define MSECS 292
+#define SECS 293
+#define HERZ 294
+#define KHERZ 295
+#define DIMEN 296
+#define PERCENTAGE 297
+#define FLOAT 298
+#define INTEGER 299
+#define URI 300
+#define FUNCTION 301
+#define NOTFUNCTION 302
+#define UNICODERANGE 303
+
+
+
+
+#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
+
+typedef union YYSTYPE {
+    CSSRuleImpl *rule;
+    CSSSelector *selector;
+    TQPtrList<CSSSelector> *selectorList;
+    bool ok;
+    MediaListImpl *mediaList;
+    CSSMediaRuleImpl *mediaRule;
+    CSSRuleListImpl *ruleList;
+    ParseString string;
+    float val;
+    int prop_id;
+    unsigned int attribute;
+    unsigned int element;
+    unsigned int ns;
+    CSSSelector::Relation relation;
+    CSSSelector::Match match;
+    bool b;
+    char tok;
+    Value value;
+    ValueList *valueList;
+} YYSTYPE;
+/* Line 1285 of yacc.c.  */
+
+# define yystype YYSTYPE /* obsolescent; will be withdrawn */
+# define YYSTYPE_IS_DECLARED 1
+# define YYSTYPE_IS_TRIVIAL 1
+#endif
+
+
+
+
+
diff --git a/tdehtml/css/parser.y b/tdehtml/css/parser.y
new file mode 100644
index 000000000..bb6f915f9
--- /dev/null
+++ b/tdehtml/css/parser.y
@@ -0,0 +1,1064 @@
+%{
+
+/*
+ *  This file is part of the KDE libraries
+ *  Copyright (C) 2002-2003 Lars Knoll (knoll@kde.org)
+ *  Copyright (c) 2003 Apple Computer
+ *  Copyright (C) 2003 Dirk Mueller (mueller@kde.org)
+ *
+ *  This library is free software; you can redistribute it and/or
+ *  modify it under the terms of the GNU Lesser 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
+ *  Lesser General Public License for more details.
+ *
+ *  You should have received a copy of the GNU Lesser General Public
+ *  License along with this library; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <string.h>
+#include <stdlib.h>
+
+#include <dom/dom_string.h>
+#include <xml/dom_docimpl.h>
+#include <css/cssstyleselector.h>
+#include <css/css_ruleimpl.h>
+#include <css/css_stylesheetimpl.h>
+#include <css/css_valueimpl.h>
+#include <misc/htmlhashes.h>
+#include "cssparser.h"
+
+#include <assert.h>
+#include <kdebug.h>
+//#define CSS_DEBUG
+
+using namespace DOM;
+
+//
+// The following file defines the function
+//     const struct props *findProp(const char *word, int len)
+//
+// with 'props->id' a CSS property in the range from CSS_PROP_MIN to
+// (and including) CSS_PROP_TOTAL-1
+
+// turn off inlining to void warning with newer gcc
+#undef __inline
+#define __inline
+#include "cssproperties.c"
+#include "cssvalues.c"
+#undef __inline
+
+int DOM::getPropertyID(const char *tagStr, int len)
+{
+    const struct props *propsPtr = findProp(tagStr, len);
+    if (!propsPtr)
+        return 0;
+
+    return propsPtr->id;
+}
+
+static inline int getValueID(const char *tagStr, int len)
+{
+    const struct css_value *val = findValue(tagStr, len);
+    if (!val)
+        return 0;
+
+    return val->id;
+}
+
+
+#define YYDEBUG 0
+#undef YYMAXDEPTH
+#define YYPARSE_PARAM parser
+%}
+
+%pure_parser
+
+%union {
+    CSSRuleImpl *rule;
+    CSSSelector *selector;
+    QPtrList<CSSSelector> *selectorList;
+    bool ok;
+    MediaListImpl *mediaList;
+    CSSMediaRuleImpl *mediaRule;
+    CSSRuleListImpl *ruleList;
+    ParseString string;
+    float val;
+    int prop_id;
+    unsigned int attribute;
+    unsigned int element;
+    unsigned int ns;
+    CSSSelector::Relation relation;
+    CSSSelector::Match match;
+    bool b;
+    char tok;
+    Value value;
+    ValueList *valueList;
+}
+
+%{
+
+static inline int cssyyerror(const char *x )
+{
+#ifdef CSS_DEBUG
+    tqDebug( "%s", x );
+#else
+    Q_UNUSED( x );
+#endif
+    return 1;
+}
+
+static int cssyylex( YYSTYPE *yylval ) {
+    return CSSParser::current()->lex( yylval );
+}
+
+#define null 1
+
+%}
+
+%destructor { delete $$; $$ = 0; } expr;
+%destructor { delete $$; $$ = 0; } maybe_media_list media_list;
+%destructor { delete $$; $$ = 0; } selector_list;
+%destructor { delete $$; $$ = 0; } ruleset_list;
+%destructor { delete $$; $$ = 0; } specifier specifier_list simple_selector selector class attrib pseudo;
+
+%no-lines
+%verbose
+
+%left UNIMPORTANT_TOK
+
+%token S SGML_CD
+
+%token INCLUDES
+%token DASHMATCH
+%token BEGINSWITH
+%token ENDSWITH
+%token CONTAINS
+
+%token <string> STRING
+
+%right <string> IDENT
+
+%token <string> NTH
+
+%nonassoc <string> HASH
+%nonassoc ':'
+%nonassoc '.'
+%nonassoc '['
+%nonassoc '*'
+%nonassoc error
+%left '|'
+
+%left IMPORT_SYM
+%token PAGE_SYM
+%token MEDIA_SYM
+%token FONT_FACE_SYM
+%token CHARSET_SYM
+%token NAMESPACE_SYM
+%token KHTML_RULE_SYM
+%token KHTML_DECLS_SYM
+%token KHTML_VALUE_SYM
+
+%token IMPORTANT_SYM
+
+%token <val> QEMS
+%token <val> EMS
+%token <val> EXS
+%token <val> PXS
+%token <val> CMS
+%token <val> MMS
+%token <val> INS
+%token <val> PTS
+%token <val> PCS
+%token <val> DEGS
+%token <val> RADS
+%token <val> GRADS
+%token <val> MSECS
+%token <val> SECS
+%token <val> HERZ
+%token <val> KHERZ
+%token <string> DIMEN
+%token <val> PERCENTAGE
+%token <val> FLOAT
+%token <val> INTEGER
+
+%token <string> URI
+%token <string> FUNCTION
+%token <string> NOTFUNCTION
+
+%token <string> UNICODERANGE
+
+%type <relation> combinator
+
+%type <rule> ruleset
+%type <rule> media
+%type <rule> import
+%type <rule> page
+%type <rule> font_face
+%type <rule> invalid_rule
+%type <rule> invalid_at
+%type <rule> rule
+
+%type <string> namespace_selector
+
+%type <string> string_or_uri
+%type <string> ident_or_string
+%type <string> medium
+%type <string> hexcolor
+%type <string> maybe_ns_prefix
+
+%type <mediaList> media_list
+%type <mediaList> maybe_media_list
+
+%type <ruleList> ruleset_list
+
+%type <prop_id> property
+
+%type <selector> specifier
+%type <selector> specifier_list
+%type <selector> simple_selector
+%type <selector> selector
+%type <selectorList> selector_list
+%type <selector> class
+%type <selector> attrib
+%type <selector> pseudo
+
+%type <ok> declaration_block
+%type <ok> declaration_list
+%type <ok> declaration
+
+%type <b> prio
+
+%type <match> match
+%type <val> unary_operator
+%type <tok> operator
+
+%type <valueList> expr
+%type <value> term
+%type <value> unary_term
+%type <value> function
+
+%type <element> element_name
+
+%type <attribute> attrib_id
+
+%%
+
+stylesheet:
+    maybe_charset maybe_sgml import_list namespace_list rule_list
+  | tdehtml_rule maybe_space
+  | tdehtml_decls maybe_space
+  | tdehtml_value maybe_space
+  ;
+
+tdehtml_rule:
+    KHTML_RULE_SYM '{' maybe_space ruleset maybe_space '}' {
+        CSSParser *p = static_cast<CSSParser *>(parser);
+	p->rule = $4;
+    }
+;
+
+tdehtml_decls:
+    KHTML_DECLS_SYM declaration_block {
+	/* can be empty */
+    }
+;
+
+tdehtml_value:
+    KHTML_VALUE_SYM '{' maybe_space expr '}' {
+	CSSParser *p = static_cast<CSSParser *>(parser);
+	if ( $4 ) {
+	    p->valueList = $4;
+#ifdef CSS_DEBUG
+	    kdDebug( 6080 ) << "   got property for " << p->id <<
+		(p->important?" important":"")<< endl;
+	    bool ok =
+#endif
+		p->parseValue( p->id, p->important );
+#ifdef CSS_DEBUG
+	    if ( !ok )
+		kdDebug( 6080 ) << "     couldn't parse value!" << endl;
+#endif
+	}
+#ifdef CSS_DEBUG
+	else
+	    kdDebug( 6080 ) << "     no value found!" << endl;
+#endif
+	delete p->valueList;
+	p->valueList = 0;
+    }
+;
+
+maybe_space:
+    /* empty */ %prec UNIMPORTANT_TOK
+  | maybe_space S
+  ;
+
+maybe_sgml:
+    /* empty */
+  | maybe_sgml SGML_CD
+  | maybe_sgml S
+  ;
+
+maybe_charset:
+   /* empty */
+ | CHARSET_SYM maybe_space STRING maybe_space ';' {
+#ifdef CSS_DEBUG
+     kdDebug( 6080 ) << "charset rule: " << qString($3) << endl;
+#endif
+ }
+  | CHARSET_SYM error invalid_block
+  | CHARSET_SYM error ';'
+ ;
+
+import_list:
+ /* empty */
+ | import_list import maybe_sgml {
+     CSSParser *p = static_cast<CSSParser *>(parser);
+     if ( $2 && p->styleElement && p->styleElement->isCSSStyleSheet() ) {
+	 p->styleElement->append( $2 );
+     } else {
+	 delete $2;
+     }
+ }
+ ;
+
+import:
+    IMPORT_SYM maybe_space string_or_uri maybe_space maybe_media_list ';' {
+#ifdef CSS_DEBUG
+	kdDebug( 6080 ) << "@import: " << qString($3) << endl;
+#endif
+	CSSParser *p = static_cast<CSSParser *>(parser);
+	if ( $5 && p->styleElement && p->styleElement->isCSSStyleSheet() )
+	    $$ = new CSSImportRuleImpl( p->styleElement, domString($3), $5 );
+	else
+	    $$ = 0;
+    }
+  | IMPORT_SYM error invalid_block {
+        $$ = 0;
+    }
+  | IMPORT_SYM error ';' {
+        $$ = 0;
+    }
+  ;
+
+namespace_list:
+    /* empty */ %prec UNIMPORTANT_TOK
+  | namespace_list namespace maybe_sgml
+;
+
+namespace:
+NAMESPACE_SYM maybe_space maybe_ns_prefix string_or_uri maybe_space ';' {
+#ifdef CSS_DEBUG
+    kdDebug( 6080 ) << "@namespace: " << qString($4) << endl;
+#endif
+      CSSParser *p = static_cast<CSSParser *>(parser);
+    if (p->styleElement && p->styleElement->isCSSStyleSheet())
+        static_cast<CSSStyleSheetImpl*>(p->styleElement)->addNamespace(p, domString($3), domString($4));
+ }
+| NAMESPACE_SYM error invalid_block
+| NAMESPACE_SYM error ';'
+    ;
+
+maybe_ns_prefix:
+/* empty */ { $$.string = 0; }
+| IDENT S { $$ = $1; }
+  ;
+
+rule_list:
+   /* empty */
+ | rule_list rule maybe_sgml {
+     CSSParser *p = static_cast<CSSParser *>(parser);
+     if ( $2 && p->styleElement && p->styleElement->isCSSStyleSheet() ) {
+	 p->styleElement->append( $2 );
+     } else {
+	 delete $2;
+     }
+ }
+    ;
+
+rule:
+    ruleset
+  | media
+  | page
+  | font_face
+  | invalid_rule
+  | invalid_at
+  | import error { delete $1; $$ = 0; }
+    ;
+
+string_or_uri:
+    STRING
+  | URI
+    ;
+
+maybe_media_list:
+    /* empty */ {
+	$$ = new MediaListImpl();
+    }
+    | media_list
+;
+
+
+media_list:
+    medium {
+	$$ = new MediaListImpl();
+	$$->appendMedium( domString($1).lower() );
+    }
+    | media_list ',' maybe_space medium {
+	$$ = $1;
+	if ($$)
+	    $$->appendMedium( domString($4).lower() );
+    }
+    | media_list error {
+       delete $1;
+       $$ = 0;
+    }
+    ;
+
+media:
+    MEDIA_SYM maybe_space media_list '{' maybe_space ruleset_list '}' {
+	CSSParser *p = static_cast<CSSParser *>(parser);
+	if ( $3 && $6 &&
+	     p->styleElement && p->styleElement->isCSSStyleSheet() ) {
+	    $$ = new CSSMediaRuleImpl( static_cast<CSSStyleSheetImpl*>(p->styleElement), $3, $6 );
+	} else {
+	    $$ = 0;
+	    delete $3;
+	    delete $6;
+	}
+    }
+  ;
+
+ruleset_list:
+    /* empty */ { $$ = 0; }
+  | ruleset_list ruleset maybe_space {
+      $$ = $1;
+      if ( $2 ) {
+	  if ( !$$ ) $$ = new CSSRuleListImpl();
+	  $$->append( $2 );
+      }
+  }
+    ;
+
+medium:
+  IDENT maybe_space {
+      $$ = $1;
+  }
+  ;
+
+/*
+page:
+    PAGE_SYM maybe_space IDENT? pseudo_page? maybe_space
+    '{' maybe_space declaration [ ';' maybe_space declaration ]* '}' maybe_space
+  ;
+
+pseudo_page
+  : ':' IDENT
+  ;
+
+font_face
+  : FONT_FACE_SYM maybe_space
+    '{' maybe_space declaration [ ';' maybe_space declaration ]* '}' maybe_space
+  ;
+*/
+
+page:
+    PAGE_SYM error invalid_block {
+      $$ = 0;
+    }
+  | PAGE_SYM error ';' {
+      $$ = 0;
+    }
+    ;
+
+font_face:
+    FONT_FACE_SYM error invalid_block {
+      $$ = 0;
+    }
+  | FONT_FACE_SYM error ';' {
+      $$ = 0;
+    }
+;
+
+combinator:
+    '+' maybe_space { $$ = CSSSelector::DirectAdjacent; }
+  | '~' maybe_space { $$ = CSSSelector::IndirectAdjacent; }
+  | '>' maybe_space { $$ = CSSSelector::Child; }
+  | /* empty */ { $$ = CSSSelector::Descendant; }
+  ;
+
+unary_operator:
+    '-' { $$ = -1; }
+  | '+' { $$ = 1; }
+  ;
+
+ruleset:
+    selector_list declaration_block {
+#ifdef CSS_DEBUG
+	kdDebug( 6080 ) << "got ruleset" << endl << "  selector:" << endl;
+#endif
+	CSSParser *p = static_cast<CSSParser *>(parser);
+	if ( $1 && $2 && p->numParsedProperties ) {
+	    CSSStyleRuleImpl *rule = new CSSStyleRuleImpl( p->styleElement );
+	    CSSStyleDeclarationImpl *decl = p->createStyleDeclaration( rule );
+	    rule->setSelector( $1 );
+	    rule->setDeclaration(decl);
+	    $$ = rule;
+	} else {
+	    $$ = 0;
+	    delete $1;
+	    p->clearProperties();
+	}
+    }
+  ;
+
+selector_list:
+    selector %prec UNIMPORTANT_TOK {
+	if ( $1 ) {
+	    $$ = new QPtrList<CSSSelector>;
+            $$->setAutoDelete( true );
+#ifdef CSS_DEBUG
+	    kdDebug( 6080 ) << "   got simple selector:" << endl;
+	    $1->print();
+#endif
+	    $$->append( $1 );
+	    tdehtml::CSSStyleSelector::precomputeAttributeDependencies(static_cast<CSSParser *>(parser)->document(), $1);
+	} else {
+	    $$ = 0;
+	}
+    }
+    | selector_list ',' maybe_space selector %prec UNIMPORTANT_TOK {
+	if ( $1 && $4 ) {
+	    $$ = $1;
+	    $$->append( $4 );
+	    tdehtml::CSSStyleSelector::precomputeAttributeDependencies(static_cast<CSSParser *>(parser)->document(), $4);
+#ifdef CSS_DEBUG
+	    kdDebug( 6080 ) << "   got simple selector:" << endl;
+	    $4->print();
+#endif
+	} else {
+	    delete $1;
+	    delete $4;
+	    $$ = 0;
+	}
+    }
+  | selector_list error {
+	delete $1;
+	$$ = 0;
+    }
+   ;
+
+selector:
+    simple_selector {
+	$$ = $1;
+    }
+    | selector combinator simple_selector {
+	if ( !$1 || !$3 ) {
+	    delete $1;
+	    delete $3;
+	    $$ = 0;
+	} else {
+	    $$ = $3;
+	    CSSSelector *end = $3;
+	    while( end->tagHistory )
+		end = end->tagHistory;
+	    end->relation = $2;
+	    end->tagHistory = $1;
+	}
+    }
+    | selector error {
+	delete $1;
+	$$ = 0;
+    }
+    ;
+
+namespace_selector:
+    /* empty */ '|' { $$.string = 0; $$.length = 0; }
+    | '*' '|' { static unsigned short star = '*'; $$.string = &star; $$.length = 1; }
+    | IDENT '|' { $$ = $1; }
+;
+
+simple_selector:
+    element_name maybe_space {
+	$$ = new CSSSelector();
+	$$->tag = $1;
+    }
+    | element_name specifier_list maybe_space {
+	$$ = $2;
+        if ( $$ )
+	    $$->tag = $1;
+    }
+    | specifier_list maybe_space {
+	$$ = $1;
+        if ( $$ )
+            $$->tag = makeId(static_cast<CSSParser*>(parser)->defaultNamespace(), anyLocalName);
+    }
+    | namespace_selector element_name maybe_space {
+        $$ = new CSSSelector();
+        $$->tag = $2;
+	CSSParser *p = static_cast<CSSParser *>(parser);
+        if (p->styleElement && p->styleElement->isCSSStyleSheet())
+            static_cast<CSSStyleSheetImpl*>(p->styleElement)->determineNamespace($$->tag, domString($1));
+    }
+    | namespace_selector element_name specifier_list maybe_space {
+        $$ = $3;
+        if ($$) {
+            $$->tag = $2;
+            CSSParser *p = static_cast<CSSParser *>(parser);
+            if (p->styleElement && p->styleElement->isCSSStyleSheet())
+                static_cast<CSSStyleSheetImpl*>(p->styleElement)->determineNamespace($$->tag, domString($1));
+        }
+    }
+    | namespace_selector specifier_list maybe_space {
+        $$ = $2;
+        if ($$) {
+            $$->tag = makeId(anyNamespace, anyLocalName);
+            CSSParser *p = static_cast<CSSParser *>(parser);
+            if (p->styleElement && p->styleElement->isCSSStyleSheet())
+                static_cast<CSSStyleSheetImpl*>(p->styleElement)->determineNamespace($$->tag, domString($1));
+        }
+    }
+  ;
+
+element_name:
+    IDENT {
+	CSSParser *p = static_cast<CSSParser *>(parser);
+	DOM::DocumentImpl *doc = p->document();
+	QString tag = qString($1);
+	if ( doc ) {
+	    if (doc->isHTMLDocument())
+		tag = tag.lower();
+	    const DOMString dtag(tag);
+            $$ = makeId(p->defaultNamespace(), doc->getId(NodeImpl::ElementId, dtag.implementation(), false, true));
+	} else {
+	    $$ = makeId(p->defaultNamespace(), tdehtml::getTagID(tag.lower().ascii(), tag.length()));
+	    // this case should never happen - only when loading
+	    // the default stylesheet - which must not contain unknown tags
+// 	    assert($$ != 0);
+	}
+    }
+    | '*' {
+	$$ = makeId(static_cast<CSSParser*>(parser)->defaultNamespace(), anyLocalName);
+    }
+  ;
+
+specifier_list:
+    specifier {
+	$$ = $1;
+	$$->nonCSSHint = static_cast<CSSParser *>(parser)->nonCSSHint;
+    }
+    | specifier_list specifier {
+	$$ = $1;
+	if ( $$ ) {
+            CSSSelector *end = $1;
+            while( end->tagHistory )
+                end = end->tagHistory;
+            end->relation = CSSSelector::SubSelector;
+            end->tagHistory = $2;
+	}
+    }
+    | specifier_list error {
+	delete $1;
+	$$ = 0;
+    }
+;
+
+specifier:
+    HASH {
+	$$ = new CSSSelector();
+	$$->match = CSSSelector::Id;
+	$$->attr = ATTR_ID;
+	$$->value = domString($1);
+    }
+  | class
+  | attrib
+  | pseudo
+    ;
+
+class:
+    '.' IDENT {
+	$$ = new CSSSelector();
+	$$->match = CSSSelector::Class;
+	$$->attr = ATTR_CLASS;
+	$$->value = domString($2);
+    }
+  ;
+
+attrib_id:
+    IDENT maybe_space {
+	CSSParser *p = static_cast<CSSParser *>(parser);
+	DOM::DocumentImpl *doc = p->document();
+
+	QString attr = qString($1);
+	if ( doc ) {
+	    if (doc->isHTMLDocument())
+		attr = attr.lower();
+	    const DOMString dattr(attr);
+#ifdef APPLE_CHANGES
+            $$ = doc->attrId(0, dattr.implementation(), false);
+#else
+	    $$ = doc->getId(NodeImpl::AttributeId, dattr.implementation(), false, true);
+#endif
+	} else {
+	    $$ = tdehtml::getAttrID(attr.lower().ascii(), attr.length());
+	    // this case should never happen - only when loading
+	    // the default stylesheet - which must not contain unknown attributes
+	    assert($$ != 0);
+	    }
+    }
+    ;
+
+attrib:
+    '[' maybe_space attrib_id ']' {
+	$$ = new CSSSelector();
+	$$->attr = $3;
+	$$->match = CSSSelector::Set;
+    }
+    | '[' maybe_space attrib_id match maybe_space ident_or_string maybe_space ']' {
+	$$ = new CSSSelector();
+	$$->attr = $3;
+	$$->match = $4;
+	$$->value = domString($6);
+    }
+    | '[' maybe_space namespace_selector attrib_id ']' {
+        $$ = new CSSSelector();
+        $$->attr = $4;
+        $$->match = CSSSelector::Set;
+        CSSParser *p = static_cast<CSSParser *>(parser);
+        if (p->styleElement && p->styleElement->isCSSStyleSheet())
+            static_cast<CSSStyleSheetImpl*>(p->styleElement)->determineNamespace($$->attr, domString($3));
+    }
+    | '[' maybe_space namespace_selector attrib_id match maybe_space ident_or_string maybe_space ']' {
+        $$ = new CSSSelector();
+        $$->attr = $4;
+        $$->match = (CSSSelector::Match)$5;
+        $$->value = domString($7);
+        CSSParser *p = static_cast<CSSParser *>(parser);
+        if (p->styleElement && p->styleElement->isCSSStyleSheet())
+            static_cast<CSSStyleSheetImpl*>(p->styleElement)->determineNamespace($$->attr, domString($3));
+   }
+  ;
+
+match:
+    '=' {
+	$$ = CSSSelector::Exact;
+    }
+    | INCLUDES {
+	$$ = CSSSelector::List;
+    }
+    | DASHMATCH {
+	$$ = CSSSelector::Hyphen;
+    }
+    | BEGINSWITH {
+	$$ = CSSSelector::Begin;
+    }
+    | ENDSWITH {
+	$$ = CSSSelector::End;
+    }
+    | CONTAINS {
+	$$ = CSSSelector::Contain;
+    }
+    ;
+
+ident_or_string:
+    IDENT
+  | STRING
+    ;
+
+pseudo:
+    ':' IDENT {
+	$$ = new CSSSelector();
+	$$->match = CSSSelector::PseudoClass;
+	$$->value = domString($2);
+    }
+    |
+    ':' ':' IDENT {
+	$$ = new CSSSelector();
+	$$->match = CSSSelector::PseudoElement;
+        $$->value = domString($3);
+    }
+    // used by :nth-*
+    | ':' FUNCTION NTH ')' {
+        $$ = new CSSSelector();
+        $$->match = CSSSelector::PseudoClass;
+        $$->string_arg = domString($3);
+        $$->value = domString($2);
+    }
+    // used by :nth-*
+    | ':' FUNCTION INTEGER ')' {
+        $$ = new CSSSelector();
+        $$->match = CSSSelector::PseudoClass;
+        $$->string_arg = QString::number($3);
+        $$->value = domString($2);
+    }
+    // used by :nth-* and :lang
+    | ':' FUNCTION IDENT ')' {
+        $$ = new CSSSelector();
+        $$->match = CSSSelector::PseudoClass;
+        $$->string_arg = domString($3);
+        $$->value = domString($2);
+    }
+    // used by :contains
+    | ':' FUNCTION STRING ')' {
+        $$ = new CSSSelector();
+        $$->match = CSSSelector::PseudoClass;
+        $$->string_arg = domString($3);
+        $$->value = domString($2);
+    }
+    // used only by :not
+    | ':' NOTFUNCTION maybe_space simple_selector ')' {
+        $$ = new CSSSelector();
+        $$->match = CSSSelector::PseudoClass;
+        $$->simpleSelector = $4;
+        $$->value = domString($2);
+    }
+  ;
+
+declaration_block:
+    '{' maybe_space declaration '}' {
+	$$ = $3;
+    }
+    | '{' maybe_space error '}' {
+	$$ = false;
+    }
+    | '{' maybe_space declaration_list '}' {
+	$$ = $3;
+    }
+    | '{' maybe_space declaration_list declaration '}' {
+	$$ = $3;
+	if ( $4 )
+	    $$ = $4;
+    }
+    | '{' maybe_space declaration_list error '}' {
+	$$ = $3;
+    }
+    ;
+
+declaration_list:
+    declaration ';' maybe_space {
+	$$ = $1;
+    }
+    |
+    error ';' maybe_space {
+        $$ = false;
+    }
+    | declaration_list declaration ';' maybe_space {
+	$$ = $1;
+	if ( $2 )
+	    $$ = $2;
+    }
+    | declaration_list error ';' maybe_space {
+        $$ = $1;
+    }
+    ;
+
+declaration:
+    property ':' maybe_space expr prio {
+	$$ = false;
+	CSSParser *p = static_cast<CSSParser *>(parser);
+	if ( $1 && $4 ) {
+	    p->valueList = $4;
+#ifdef CSS_DEBUG
+	    kdDebug( 6080 ) << "   got property: " << $1 <<
+		($5?" important":"")<< endl;
+#endif
+	        bool ok = p->parseValue( $1, $5 );
+                if ( ok )
+		    $$ = ok;
+#ifdef CSS_DEBUG
+	        else
+		    kdDebug( 6080 ) << "     couldn't parse value!" << endl;
+#endif
+	} else {
+            delete $4;
+        }
+	delete p->valueList;
+	p->valueList = 0;
+    }
+    | error invalid_block {
+        $$ = false;
+    }
+  ;
+
+property:
+    IDENT maybe_space {
+	QString str = qString($1);
+	$$ = getPropertyID( str.lower().latin1(), str.length() );
+    }
+  ;
+
+prio:
+    IMPORTANT_SYM maybe_space { $$ = true; }
+    | /* empty */ { $$ = false; }
+  ;
+
+expr:
+    term {
+	$$ = new ValueList;
+	$$->addValue( $1 );
+    }
+    | expr operator term {
+	$$ = $1;
+	if ( $$ ) {
+	    if ( $2 ) {
+		Value v;
+		v.id = 0;
+		v.unit = Value::Operator;
+		v.iValue = $2;
+		$$->addValue( v );
+	    }
+	    $$->addValue( $3 );
+	}
+    }
+  ;
+
+operator:
+    '/' maybe_space {
+	$$ = '/';
+    }
+  | ',' maybe_space {
+	$$ = ',';
+    }
+  | /* empty */ {
+        $$ = 0;
+  }
+  ;
+
+term:
+  unary_term { $$ = $1; }
+   | unary_operator unary_term { $$ = $2; $$.fValue *= $1; }
+  /* DIMEN is an unary_term, but since we store the string we must not modify fValue */
+  | DIMEN maybe_space { $$.id = 0; $$.string = $1; $$.unit = CSSPrimitiveValue::CSS_DIMENSION; }
+  | STRING maybe_space { $$.id = 0; $$.string = $1; $$.unit = CSSPrimitiveValue::CSS_STRING; }
+  | IDENT maybe_space {
+      QString str = qString( $1 );
+      $$.id = getValueID( str.lower().latin1(), str.length() );
+      $$.unit = CSSPrimitiveValue::CSS_IDENT;
+      $$.string = $1;
+  }
+  | URI maybe_space { $$.id = 0; $$.string = $1; $$.unit = CSSPrimitiveValue::CSS_URI; }
+  | UNICODERANGE maybe_space { $$.id = 0; $$.iValue = 0; $$.unit = CSSPrimitiveValue::CSS_UNKNOWN;/* ### */ }
+  | hexcolor { $$.id = 0; $$.string = $1; $$.unit = CSSPrimitiveValue::CSS_RGBCOLOR; }
+/* ### according to the specs a function can have a unary_operator in front. I know no case where this makes sense */
+  | function {
+      $$ = $1;
+  }
+  ;
+
+unary_term:
+  INTEGER maybe_space { $$.id = 0; $$.isInt = true; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_NUMBER; }
+  | FLOAT maybe_space { $$.id = 0; $$.isInt = false; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_NUMBER; }
+  | PERCENTAGE maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_PERCENTAGE; }
+  | PXS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_PX; }
+  | CMS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_CM; }
+  | MMS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_MM; }
+  | INS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_IN; }
+  | PTS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_PT; }
+  | PCS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_PC; }
+  | DEGS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_DEG; }
+  | RADS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_RAD; }
+  | GRADS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_GRAD; }
+  | MSECS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_MS; }
+  | SECS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_S; }
+  | HERZ maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_HZ; }
+  | KHERZ maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_KHZ; }
+  | EMS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_EMS; }
+  | QEMS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = Value::Q_EMS; }
+  | EXS maybe_space { $$.id = 0; $$.fValue = $1; $$.unit = CSSPrimitiveValue::CSS_EXS; }
+    ;
+
+
+function:
+  FUNCTION maybe_space expr ')' maybe_space {
+      Function *f = new Function;
+      f->name = $1;
+      f->args = $3;
+      $$.id = 0;
+      $$.unit = Value::Function;
+      $$.function = f;
+  }
+  | FUNCTION maybe_space error {
+      Function *f = new Function;
+      f->name = $1;
+      f->args = 0;
+      $$.id = 0;
+      $$.unit = Value::Function;
+      $$.function = f;
+  }
+
+  ;
+/*
+ * There is a constraint on the color that it must
+ * have either 3 or 6 hex-digits (i.e., [0-9a-fA-F])
+ * after the "#"; e.g., "#000" is OK, but "#abcd" is not.
+ */
+hexcolor:
+  HASH maybe_space { $$ = $1; }
+  ;
+
+
+/* error handling rules */
+
+invalid_at:
+    '@' error invalid_block {
+	$$ = 0;
+#ifdef CSS_DEBUG
+	kdDebug( 6080 ) << "skipped invalid @-rule" << endl;
+#endif
+    }
+  | '@' error ';' {
+	$$ = 0;
+#ifdef CSS_DEBUG
+	kdDebug( 6080 ) << "skipped invalid @-rule" << endl;
+#endif
+    }
+    ;
+
+invalid_rule:
+    error invalid_block {
+	$$ = 0;
+#ifdef CSS_DEBUG
+	kdDebug( 6080 ) << "skipped invalid rule" << endl;
+#endif
+    }
+/*
+  Seems like the two rules below are trying too much and violating
+  http://www.hixie.ch/tests/evil/mixed/csserrorhandling.html
+
+  | error ';' {
+	$$ = 0;
+#ifdef CSS_DEBUG
+	kdDebug( 6080 ) << "skipped invalid rule" << endl;
+#endif
+    }
+  | error '}' {
+	$$ = 0;
+#ifdef CSS_DEBUG
+	kdDebug( 6080 ) << "skipped invalid rule" << endl;
+#endif
+    }
+*/
+    ;
+
+invalid_block:
+    '{' error invalid_block_list error '}'
+  | '{' error '}'
+    ;
+
+invalid_block_list:
+    invalid_block
+  | invalid_block_list error invalid_block
+;
+
+%%
+
diff --git a/tdehtml/css/quirks.css b/tdehtml/css/quirks.css
new file mode 100644
index 000000000..b979b77c9
--- /dev/null
+++ b/tdehtml/css/quirks.css
@@ -0,0 +1,41 @@
+/*
+ * This style sheet is used by tdehtml to render HTML pages in quirks mode
+ * (C) 2000-2003 Lars Knoll (knoll@kde.org)
+ *
+ * Konqueror/tdehtml relies on the existence of this style sheet for
+ * rendering. Do not remove or modify this file unless you know
+ * what you are doing.
+ */
+
+/* Give floated images margins of 3px */
+img[align="left"] {
+    margin-right: 3px;
+}
+
+img[align="right"] {
+    margin-left: 3px;
+}
+
+/* Tables reset both line-height and white-space in quirks mode.
+   Compatible with WinIE. For some reason they don't reset font-family */
+table {
+    white-space: normal;
+    line-height: normal;
+    color: -tdehtml-text;
+    font-size: medium;
+    empty-cells: hide;
+    text-align: -tdehtml-auto;
+    font-weight: initial;
+}
+
+LAYER {
+    position: absolute;
+}
+
+DIV > LAYER {
+    position: static;
+}
+
+ILAYER > LAYER {
+    position: relative;
+}
\ No newline at end of file
diff --git a/tdehtml/css/tokenizer.cpp b/tdehtml/css/tokenizer.cpp
new file mode 100644
index 000000000..493a98032
--- /dev/null
+++ b/tdehtml/css/tokenizer.cpp
@@ -0,0 +1,930 @@
+/*
+ * This file is part of the DOM implementation for KDE.
+ *
+ * Copyright (C) 2003 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 is mostly data generated by flex. Unfortunately flex
+   can't handle 16bit strings directly, so we just copy the part of
+   the code we need and modify it to our needs.
+
+   Most of the defines below are to make sure we can easily use the
+   flex generated code, using as little editing as possible.
+
+   The flex syntax to generate the lexer are more or less directly
+   copied from the CSS2.1 specs, with some fixes for comments and
+   the important symbol.
+
+   To regenerate, run flex on tokenizer.flex. After this, copy the
+   data tables and the YY_DECL method over to this file. Remove the
+   init code from YY_DECL and change the YY_END_OF_BUFFER to only call
+   yyterminate().
+
+*/
+
+// --------- begin generated code -------------------
+#define YY_NUM_RULES 51
+#define YY_END_OF_BUFFER 52
+static yyconst short int yy_accept[331] =
+    {   0,
+        0,    0,   52,   50,    2,    2,   50,   50,   50,   50,
+       50,   50,   50,   50,   50,   42,   50,   50,   50,   50,
+       11,   11,   11,   50,   50,    2,    0,    0,    0,   10,
+        0,   13,    0,    8,    0,    0,    9,    0,    0,    0,
+       11,   11,   43,    0,   41,    0,    0,   42,    0,   40,
+       40,   40,   40,   40,   40,   40,   40,   40,   40,   12,
+       40,   40,   37,    0,    0,    0,    0,    0,    0,    0,
+        0,   11,   11,    7,   47,   11,    0,    0,   11,   11,
+        0,   11,    6,    5,    0,    0,    0,   10,    0,    0,
+       13,   13,    0,    0,   10,    0,    0,    4,   12,    0,
+
+        0,   40,   40,   40,    0,   40,   28,   40,   24,   26,
+       40,   38,   30,   40,   29,   36,   40,   32,   31,   27,
+       40,    0,    0,    0,    0,    0,    0,    0,    0,   11,
+       11,   11,   12,   11,   11,   48,   48,   11,    0,    0,
+        0,   13,    0,    0,    0,    1,   40,   40,   40,   40,
+       33,   40,   39,   12,   34,    3,    0,    0,    0,    0,
+        0,    0,    0,   11,   11,   44,    0,   48,   48,   48,
+       47,    0,    0,   13,    0,    0,    0,   40,   40,   40,
+       35,    0,    0,    0,    0,    0,    0,   15,   11,   11,
+       49,   48,   48,   48,   48,    0,    0,    0,    0,   46,
+
+        0,    0,    0,   13,    0,   40,   40,   25,    0,    0,
+        0,    0,   16,    0,   11,   11,   49,   48,   48,   48,
+       48,   48,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,   46,    0,    0,    0,    0,   13,    0,   40,   40,
+        0,    0,    0,   14,    0,   11,   11,   49,   48,   48,
+       48,   48,   48,   48,    0,   45,    0,    0,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,   13,
+        0,   40,   40,    0,   18,    0,    0,   11,   49,   48,
+       48,   48,   48,   48,   48,   48,    0,   45,    0,    0,
+        0,   45,    0,    0,    0,    0,   40,    0,    0,    0,
+
+        0,    0,   49,    0,    0,    0,   23,    0,    0,    0,
+       17,   19,   49,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,    0,   20,    0,    0,    0,   21,   22,    0
+    } ;
+
+static yyconst int yy_ec[256] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
+        1,    4,    5,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    6,    7,    8,    9,   10,   11,   12,   13,   14,
+       15,   16,   17,   12,   18,   19,   20,   21,   21,   21,
+       21,   21,   21,   21,   21,   21,   21,   12,   12,   22,
+       23,   24,   25,   26,   30,   31,   32,   33,   34,   35,
+       36,   37,   38,   39,   40,   41,   42,   43,   44,   45,
+       46,   47,   48,   49,   50,   51,   39,   52,   39,   53,
+       12,   27,   12,   28,   29,   12,   30,   31,   32,   33,
+
+       34,   35,   36,   37,   38,   39,   40,   41,   42,   43,
+       44,   45,   46,   47,   48,   49,   50,   51,   39,   52,
+       39,   53,   12,   54,   12,   55,    1,   56,   56,   56,
+       56,   56,   56,   56,   56,   56,   56,   56,   56,   56,
+       56,   56,   56,   56,   56,   56,   56,   56,   56,   56,
+       56,   56,   56,   56,   56,   56,   56,   56,   56,   56,
+       56,   56,   56,   56,   56,   56,   56,   56,   56,   56,
+       56,   56,   56,   56,   56,   56,   56,   56,   56,   56,
+       56,   56,   56,   56,   56,   56,   56,   56,   56,   56,
+       56,   56,   56,   56,   56,   56,   56,   56,   56,   56,
+
+       56,   56,   56,   56,   56,   56,   56,   56,   56,   56,
+       56,   56,   56,   56,   56,   56,   56,   56,   56,   56,
+       56,   56,   56,   56,   56,   56,   56,   56,   56,   56,
+       56,   56,   56,   56,   56,   56,   56,   56,   56,   56,
+       56,   56,   56,   56,   56,   56,   56,   56,   56,   56,
+       56,   56,   56,   56,   56
+    } ;
+
+static yyconst int yy_meta[57] =
+    {   0,
+        1,    2,    3,    3,    3,    4,    4,    4,    4,    4,
+        4,    4,    4,    5,    4,    4,    4,    6,    4,    4,
+        6,    4,    4,    4,    7,    4,    8,    4,    8,    9,
+        9,    9,    9,    9,    9,    8,    8,    8,    8,    8,
+        8,    8,    8,    8,    8,    8,    8,    8,    8,    8,
+        8,    8,    8,    4,    4,    8
+    } ;
+
+static yyconst short int yy_base[359] =
+    {   0,
+        0,    0,  807, 1638,   55,   60,   65,   64,  779,  781,
+       60,  780,   56,  781,  785,   93,  793,   63,  126,  773,
+       61,   75,  136,  772,  771,  162,  167,  751,   70, 1638,
+      204,  764,  154, 1638,   63,  238, 1638,  760,   64,  160,
+       82,  183,  133,  767, 1638,  755,  760,    0,  183,   53,
+      753,   52,   83,  169,  135,  121,   57,  192,  205,  206,
+      225,   86,  745,  752,  729,  731,  723,  716,  723,  726,
+      725,  231,  276, 1638, 1638,  234,  254,  733,  235,  249,
+      291,  277, 1638, 1638,  701,  195,  172,  219,  325,  359,
+      717,  393,  217,  237,  286,  427,  461, 1638,  160,  727,
+
+      135,  715,  495,  714,  344,  256,  700,  265,  699,  698,
+       88,  697,  696,  175,  695,  694,  233,  693,  679,  678,
+      267,  684,  664,  670,  656,  640,  651,  622,  627,  446,
+      305,  529,  639,  320,  321,  318,  634,  323,  614,  287,
+      521,  536,  326,  544,  641, 1638,  551,  621,  585,  311,
+      619,  339,  618,  360,  617, 1638,  594,  582,  556,  559,
+      564,  567,  566,  577,  592, 1638,  600,  324,  574,  572,
+      634,  549,  620,  635,  641,  579,  324,  656,  662,  278,
+      567,  551,  544,  562,  526,  528,  501, 1638,  677,  683,
+      698,  382,  523,  522,  521,  732,  758,  288,  341, 1638,
+
+      784,  496,  718,  744,  791,  799,  806,  517,  502,  489,
+      486,  471, 1638,  474,  814,  821,  829,  383,  493,  485,
+      484,  481,  400,  343,  407,  863,  356,  897,  931,  957,
+      983, 1009, 1035, 1069,  475,  848,  882,  917,  943,  969,
+      486,  453,  460, 1638,  445,  995, 1076, 1084,  416,  448,
+      447,  444,  443,  426,  440, 1638,  444,  408,  509, 1118,
+     1152,  601,  358, 1131, 1186, 1220, 1205,  407, 1227, 1235,
+     1242,  481, 1250,  456, 1638,  417,  406,  535, 1257,  403,
+     1638, 1638, 1638, 1638, 1638, 1638, 1049,  409,  410, 1265,
+     1299,  426,  443, 1285, 1300,  370,  676,  354,  334,  352,
+
+      339,  283, 1306, 1321, 1327, 1342, 1638,  261,  226,  225,
+     1638, 1638, 1638, 1348, 1363, 1369,  214,  192,  129, 1384,
+     1390, 1405,   73, 1638,   52, 1411, 1426, 1638, 1638, 1638,
+     1460, 1464, 1472, 1476, 1482, 1487, 1495, 1501, 1509, 1518,
+     1520, 1526, 1530, 1536, 1545, 1551, 1555, 1564, 1568, 1576,
+     1580, 1588, 1596, 1604, 1608, 1616, 1624, 1628
+    } ;
+
+static yyconst short int yy_def[359] =
+    {   0,
+      330,    1,  330,  330,  330,  330,  330,  331,  332,  330,
+      333,  330,  334,  330,  330,  330,  330,  330,  335,  330,
+      336,  336,  336,  330,  330,  330,  330,  330,  331,  330,
+      337,  332,  338,  330,  333,  339,  330,  330,  330,  335,
+      336,  336,   16,  340,  330,  341,  330,   16,  342,  343,
+      343,  343,  343,  343,  343,  343,  343,  343,  343,  343,
+      343,  343,  343,  330,  330,  330,  330,  330,  330,  330,
+      330,  336,  336,  330,  330,  336,  344,  330,  336,  336,
+      330,  336,  330,  330,  330,  331,  331,  331,  331,  337,
+      332,  332,  333,  333,  333,  333,  339,  330,  330,  340,
+
+      345,  343,  343,  343,  346,  343,  343,  343,  343,  343,
+      343,  343,  343,  343,  343,  343,  343,  343,  343,  343,
+      343,  330,  330,  330,  330,  330,  330,  330,  330,   73,
+      336,   73,  330,  336,  336,  347,  330,  336,  330,  331,
+       89,   92,  333,   96,  348,  330,  103,  343,  103,  343,
+      343,  343,  343,  343,  343,  330,  330,  330,  330,  330,
+      330,  330,  330,   73,  132,  330,  330,  349,  330,  330,
+      350,  330,   89,   92,   96,  348,  345,  103,  149,  343,
+      343,  330,  330,  330,  330,  330,  330,  330,   73,  132,
+      330,  351,  330,  330,  330,  350,  350,  352,  353,  330,
+
+      354,  330,   89,   92,   96,  103,  149,  343,  330,  330,
+      330,  330,  330,  330,   73,  132,  330,  355,  330,  330,
+      330,  330,  330,  352,  330,  356,  353,  357,  350,  350,
+      350,  350,  350,  354,  330,   89,   92,   96,  103,  149,
+      330,  330,  330,  330,  330,   73,  132,  330,  358,  330,
+      330,  330,  330,  330,  330,  330,  352,  352,  352,  352,
+      356,  353,  353,  353,  353,  357,  233,  330,   89,   92,
+       96,  343,  149,  330,  330,  330,  330,  246,  330,  330,
+      330,  330,  330,  330,  330,  330,  352,  352,  352,  260,
+      353,  353,  353,  265,  233,  330,  343,  330,  330,  330,
+
+      330,  330,  330,  260,  265,  233,  330,  330,  330,  330,
+      330,  330,  330,  260,  265,  233,  330,  330,  330,  260,
+      265,  233,  330,  330,  330,  260,  265,  330,  330,    0,
+      330,  330,  330,  330,  330,  330,  330,  330,  330,  330,
+      330,  330,  330,  330,  330,  330,  330,  330,  330,  330,
+      330,  330,  330,  330,  330,  330,  330,  330
+    } ;
+
+static yyconst short int yy_nxt[1695] =
+    {   0,
+        4,    5,    6,    5,    5,    5,    7,    8,    9,   10,
+        4,    4,   11,    4,    4,   12,    4,   13,   14,   15,
+       16,   17,    4,    4,    4,   18,   19,   20,   21,   21,
+       21,   21,   21,   21,   21,   21,   21,   21,   21,   21,
+       21,   21,   22,   21,   21,   21,   21,   21,   21,   23,
+       21,   21,   21,   24,   25,   21,   26,   26,   26,   26,
+       26,   26,   26,   26,   26,   26,   27,   27,   27,   27,
+       27,   30,   30,   38,   75,   30,   39,   30,  105,  105,
+       65,  106,   40,  105,   39,  329,   36,   77,   75,   36,
+       31,   78,   79,  107,   66,   75,   31,   67,   42,  113,
+
+       68,   77,   28,   45,   69,   70,   99,   71,   77,  105,
+       46,   47,  105,   48,  105,  121,  108,  152,   80,   49,
+      328,   50,   51,   51,   52,   53,   54,   51,   55,   56,
+       57,   51,   58,   51,   59,   60,   51,   61,   51,   62,
+       63,   51,   51,   51,   51,   51,   73,  105,   51,   75,
+      101,  330,   81,   43,  146,   73,   73,   73,   73,   73,
+       73,  105,   77,   26,   26,   26,   26,   26,   27,   27,
+       27,   27,   27,  112,   92,   51,   78,   78,  325,   30,
+       73,  111,   82,   92,   92,   92,   92,   92,   92,   73,
+       73,   73,   73,   73,   73,  105,   75,   29,   31,   78,
+
+       79,  105,   30,  103,   28,   29,   29,   29,   86,   77,
+      109,   88,  103,  103,  103,  103,  103,  103,  105,   35,
+      110,   31,   78,  117,   89,  324,   30,  153,  114,   30,
+       90,  105,  105,   89,   89,   89,   89,   89,   89,   35,
+       35,   35,   93,   36,   75,   31,  115,   75,   75,   30,
+       95,  105,  116,  154,  323,  134,  118,   77,   96,  105,
+       77,   77,   75,   36,   97,  319,  318,   96,   96,   96,
+       96,   96,   96,  119,  132,   77,  120,   72,   72,   72,
+       72,   72,  105,  132,  132,  132,  132,  132,  132,   75,
+       75,  105,  317,  105,   30,  225,  130,  135,   30,  155,
+
+      151,  150,   77,   77,  105,  130,  130,  130,  130,  130,
+      130,  136,   36,   31,  226,  137,  312,  138,   75,  208,
+      136,  136,  136,  136,  136,  136,   87,  140,  140,  140,
+       87,   77,   30,   75,  166,  167,  171,  105,   30,  177,
+      134,  167,  169,  146,  180,  141,   77,   77,  193,   77,
+      225,   31,   36,  225,  141,  141,  141,  141,  141,  141,
+       29,   29,   29,   86,  149,  105,   88,  228,  225,  226,
+      225,  181,  311,  149,  149,  149,  149,  149,  149,   89,
+      154,  310,  228,  309,  228,   90,  105,  308,   89,   89,
+       89,   89,   89,   89,   91,   91,   91,   91,   91,  167,
+
+      167,  223,  223,  223,  223,  223,  219,  250,  255,  255,
+      255,  255,  255,  142,  200,  225,  225,  225,  307,   33,
+      167,  256,  142,  142,  142,  142,  142,  142,   94,  143,
+      143,  143,   94,  167,  226,  226,  226,  302,  225,   30,
+      281,  255,  255,  255,  255,  255,  224,  144,  301,  296,
+      286,  225,  228,   36,  256,  225,  144,  144,  144,  144,
+      144,  144,   35,   35,   35,   93,  164,  285,  284,  228,
+      226,  283,  282,   95,  277,  164,  164,  164,  164,  164,
+      164,   96,  102,  102,  102,  102,  102,   97,  298,  276,
+       96,   96,   96,   96,   96,   96,  102,  102,  102,  102,
+
+      102,  275,  299,  274,  268,  254,  300,  105,  253,  252,
+      287,  255,  255,  255,  287,  147,  225,  251,  245,  244,
+      243,  105,  242,  288,  147,  147,  147,  147,  147,  147,
+      131,  131,  131,  131,  131,  226,  131,  131,  131,  131,
+      131,  173,  241,  105,  235,  222,  221,  220,  214,  165,
+      173,  173,  173,  173,  173,  173,  174,  213,  165,  165,
+      165,  165,  165,  165,  175,  174,  174,  174,  174,  174,
+      174,  178,  212,  175,  175,  175,  175,  175,  175,  211,
+      178,  178,  178,  178,  178,  178,  148,  148,  148,  148,
+      148,  210,  209,  105,  177,  202,  195,  189,  194,  188,
+
+      187,  186,  185,  227,  184,  179,  189,  189,  189,  189,
+      189,  189,  190,  225,  179,  179,  179,  179,  179,  179,
+      191,  190,  190,  190,  190,  190,  190,  228,  183,  191,
+      191,  191,  191,  191,  191,  196,  196,  196,  196,  196,
+      203,  198,  182,  105,  105,  105,  199,  105,  200,  203,
+      203,  203,  203,  203,  203,  204,  177,  172,  170,  133,
+      201,  205,  163,  162,  204,  204,  204,  204,  204,  204,
+      205,  205,  205,  205,  205,  205,  206,  148,  148,  148,
+      148,  148,  207,  161,  160,  206,  206,  206,  206,  206,
+      206,  207,  207,  207,  207,  207,  207,  215,  159,  158,
+
+      157,  156,  105,  216,  105,  105,  215,  215,  215,  215,
+      215,  215,  216,  216,  216,  216,  216,  216,  217,  105,
+      105,  105,  105,  105,  105,  105,  105,  217,  217,  217,
+      217,  217,  217,  196,  196,  196,  196,  196,  236,  198,
+      105,  105,  101,   33,  199,  139,  200,  236,  236,  236,
+      236,  236,  236,  133,  129,  128,  127,  126,  201,  223,
+      223,  223,  223,  223,  237,  330,  125,  124,  123,  122,
+      330,  105,  200,  237,  237,  237,  237,  237,  237,  105,
+       43,   49,  101,   98,  201,  223,  223,  223,  223,  229,
+       33,  231,   85,   84,   83,   74,  231,  231,  232,   64,
+
+       44,   43,   37,   34,  233,   33,  330,  330,  330,  330,
+      234,  238,  330,  233,  233,  233,  233,  233,  233,  239,
+      238,  238,  238,  238,  238,  238,  240,  330,  239,  239,
+      239,  239,  239,  239,  246,  240,  240,  240,  240,  240,
+      240,  247,  330,  246,  246,  246,  246,  246,  246,  248,
+      247,  247,  247,  247,  247,  247,  330,  330,  248,  248,
+      248,  248,  248,  248,  224,  224,  224,  257,  269,  330,
+      259,  330,  330,  330,  330,  330,  330,  269,  269,  269,
+      269,  269,  269,  260,  330,  330,  330,  330,  330,  261,
+      330,  330,  260,  260,  260,  260,  260,  260,  227,  227,
+
+      227,  262,  270,  330,  330,  330,  330,  330,  330,  264,
+      330,  270,  270,  270,  270,  270,  270,  265,  330,  330,
+      330,  330,  330,  266,  330,  330,  265,  265,  265,  265,
+      265,  265,  223,  223,  223,  223,  223,  271,  330,  330,
+      330,  330,  330,  330,  330,  200,  271,  271,  271,  271,
+      271,  271,  330,  330,  330,  330,  330,  201,  223,  223,
+      223,  223,  223,  272,  330,  330,  330,  330,  330,  330,
+      330,  200,  272,  272,  272,  272,  272,  272,  330,  330,
+      330,  330,  330,  201,  223,  223,  223,  223,  223,  273,
+      330,  330,  330,  330,  330,  330,  330,  200,  273,  273,
+
+      273,  273,  273,  273,  330,  330,  330,  330,  330,  201,
+      223,  223,  223,  223,  223,   76,  330,  330,  330,  330,
+      330,  330,  330,  200,   76,   76,   76,   76,   76,   76,
+      330,  330,  330,  330,  330,  201,  229,  229,  229,  229,
+      229,  330,  330,  330,  330,  330,  330,  330,  330,  200,
+      287,  255,  255,  255,  287,  267,  225,  330,  330,  330,
+      330,  201,  330,  288,  267,  267,  267,  267,  267,  267,
+      223,  223,  223,  223,  229,  226,  231,  330,  330,  330,
+      330,  231,  231,  232,  330,  330,  330,  330,  330,  233,
+      330,  330,  330,  330,  330,  234,  278,  330,  233,  233,
+
+      233,  233,  233,  233,  279,  278,  278,  278,  278,  278,
+      278,  330,  330,  279,  279,  279,  279,  279,  279,  258,
+      289,  289,  289,  258,  330,  225,  330,  330,  330,  330,
+      330,  330,  291,  255,  255,  255,  291,  330,  290,  330,
+      330,  330,  330,  225,  226,  292,  330,  290,  290,  290,
+      290,  290,  290,  224,  224,  224,  257,  228,  330,  259,
+      330,  330,  330,  330,  330,  330,  330,  330,  330,  330,
+      330,  330,  260,  330,  330,  330,  330,  330,  261,  330,
+      330,  260,  260,  260,  260,  260,  260,  263,  293,  293,
+      293,  263,  330,  330,  330,  330,  330,  330,  225,  330,
+
+      330,  330,  330,  330,  330,  330,  294,  330,  330,  330,
+      330,  330,  228,  330,  330,  294,  294,  294,  294,  294,
+      294,  227,  227,  227,  262,  295,  330,  330,  330,  330,
+      330,  330,  264,  330,  295,  295,  295,  295,  295,  295,
+      265,  330,  330,  330,  330,  330,  266,   29,  330,  265,
+      265,  265,  265,  265,  265,   32,   29,   29,   29,   29,
+       29,   29,   35,  330,   32,   32,   32,   32,   32,   32,
+      297,   35,   35,   35,   35,   35,   35,  303,  330,  297,
+      297,  297,  297,  297,  297,  304,  303,  303,  303,  303,
+      303,  303,  330,  330,  304,  304,  304,  304,  304,  304,
+
+      291,  255,  255,  255,  291,  305,  330,  330,  330,  330,
+      330,  225,  330,  292,  305,  305,  305,  305,  305,  305,
+      306,  330,  330,  330,  330,  228,  313,  330,  330,  306,
+      306,  306,  306,  306,  306,  313,  313,  313,  313,  313,
+      313,  314,  330,  330,  330,  330,  330,  315,  330,  330,
+      314,  314,  314,  314,  314,  314,  315,  315,  315,  315,
+      315,  315,  316,  330,  330,  330,  330,  330,  320,  330,
+      330,  316,  316,  316,  316,  316,  316,  320,  320,  320,
+      320,  320,  320,  321,  330,  330,  330,  330,  330,  322,
+      330,  330,  321,  321,  321,  321,  321,  321,  322,  322,
+
+      322,  322,  322,  322,  326,  330,  330,  330,  330,  330,
+      327,  330,  330,  326,  326,  326,  326,  326,  326,  327,
+      327,  327,  327,  327,  327,  197,  330,  330,  330,  330,
+      330,  224,  330,  330,  197,  197,  197,  197,  197,  197,
+      224,  224,  224,  224,  224,  224,  227,  330,  330,  330,
+      330,  330,  330,  330,  330,  227,  227,  227,  227,  227,
+      227,   29,  330,   29,   29,   29,   29,   29,   29,   32,
+      330,   32,   32,   35,  330,   35,   35,   35,   35,   35,
+       35,   41,  330,   41,   41,   72,   72,   72,   72,   72,
+       72,   76,   76,  330,   76,   76,   87,   87,   87,   87,
+
+       87,   87,   87,   87,   91,   91,   91,   91,   91,   91,
+       94,   94,   94,   94,   94,   94,   94,   94,  100,  100,
+      100,  100,  100,  100,  100,  100,  100,   51,   51,  102,
+      102,  102,  102,  102,  102,  104,  330,  104,  104,  131,
+      131,  131,  131,  131,  131,  145,  145,  145,  145,  145,
+      145,  145,  145,  145,  148,  148,  148,  148,  148,  148,
+      168,  168,  330,  168,  176,  176,  176,  176,  176,  176,
+      176,  176,  176,  192,  192,  330,  192,  197,  197,  197,
+      330,  197,  197,  197,  197,  218,  218,  330,  218,  224,
+      330,  224,  224,  224,  224,  224,  224,  227,  330,  227,
+
+      227,  227,  227,  227,  227,  230,  230,  230,  230,  230,
+      230,  230,  230,  249,  249,  330,  249,  258,  258,  258,
+      258,  258,  258,  258,  258,  263,  263,  263,  263,  263,
+      263,  263,  263,  280,  280,  330,  280,    3,  330,  330,
+      330,  330,  330,  330,  330,  330,  330,  330,  330,  330,
+      330,  330,  330,  330,  330,  330,  330,  330,  330,  330,
+      330,  330,  330,  330,  330,  330,  330,  330,  330,  330,
+      330,  330,  330,  330,  330,  330,  330,  330,  330,  330,
+      330,  330,  330,  330,  330,  330,  330,  330,  330,  330,
+      330,  330,  330,  330
+
+    } ;
+
+static yyconst short int yy_chk[1695] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    5,    5,    5,    5,
+        5,    6,    6,    6,    6,    6,    7,    7,    7,    7,
+        7,    8,   11,   13,   21,   35,   13,   29,   52,   50,
+       18,   50,   13,   57,   39,  325,   11,   21,   22,   35,
+        8,   22,   22,   52,   18,   41,   29,   18,   13,   57,
+
+       18,   22,    7,   16,   18,   18,   39,   18,   41,   53,
+       16,   16,   62,   16,  111,   62,   53,  111,   22,   16,
+      323,   16,   16,   16,   16,   16,   16,   16,   16,   16,
+       16,   16,   16,   16,   16,   16,   16,   16,   16,   16,
+       16,   16,   16,   16,   16,   16,   19,   56,   16,   23,
+      101,   43,   23,   43,  101,   19,   19,   19,   19,   19,
+       19,   55,   23,   26,   26,   26,   26,   26,   27,   27,
+       27,   27,   27,   56,   33,   43,   99,   99,  319,   87,
+       40,   55,   23,   33,   33,   33,   33,   33,   33,   40,
+       40,   40,   40,   40,   40,   54,   42,   86,   87,   42,
+
+       42,  114,   86,   49,   27,   31,   31,   31,   31,   42,
+       54,   31,   49,   49,   49,   49,   49,   49,   58,   93,
+       54,   86,   60,   60,   31,  318,   88,  114,   58,   93,
+       31,   59,   60,   31,   31,   31,   31,   31,   31,   36,
+       36,   36,   36,   93,   72,   88,   59,   76,   79,   94,
+       36,   61,   59,  117,  317,   79,   61,   72,   36,  117,
+       76,   79,   80,   94,   36,  310,  309,   36,   36,   36,
+       36,   36,   36,   61,   77,   80,   61,   73,   73,   73,
+       73,   73,  106,   77,   77,   77,   77,   77,   77,   73,
+       82,  108,  308,  121,  140,  198,   73,   80,   95,  121,
+
+      108,  106,   73,   82,  180,   73,   73,   73,   73,   73,
+       73,   81,   95,  140,  198,   81,  302,   82,  131,  180,
+       81,   81,   81,   81,   81,   81,   89,   89,   89,   89,
+       89,  131,   89,  134,  135,  136,  138,  150,  143,  177,
+      134,  168,  136,  177,  150,   89,  134,  135,  168,  138,
+      224,   89,  143,  199,   89,   89,   89,   89,   89,   89,
+       90,   90,   90,   90,  105,  152,   90,  199,  227,  224,
+      263,  152,  301,  105,  105,  105,  105,  105,  105,   90,
+      154,  300,  227,  299,  263,   90,  154,  298,   90,   90,
+       90,   90,   90,   90,   92,   92,   92,   92,   92,  192,
+
+      218,  223,  223,  223,  223,  223,  192,  218,  225,  225,
+      225,  225,  225,   92,  223,  258,  288,  289,  296,   92,
+      280,  225,   92,   92,   92,   92,   92,   92,   96,   96,
+       96,   96,   96,  249,  258,  288,  289,  277,  292,   96,
+      249,  255,  255,  255,  255,  255,  257,   96,  276,  268,
+      254,  257,  292,   96,  255,  293,   96,   96,   96,   96,
+       96,   96,   97,   97,   97,   97,  130,  253,  252,  293,
+      257,  251,  250,   97,  245,  130,  130,  130,  130,  130,
+      130,   97,  272,  272,  272,  272,  272,   97,  274,  243,
+       97,   97,   97,   97,   97,   97,  103,  103,  103,  103,
+
+      103,  242,  274,  241,  235,  222,  274,  272,  221,  220,
+      259,  259,  259,  259,  259,  103,  259,  219,  214,  212,
+      211,  103,  210,  259,  103,  103,  103,  103,  103,  103,
+      132,  132,  132,  132,  132,  259,  278,  278,  278,  278,
+      278,  141,  209,  208,  202,  195,  194,  193,  187,  132,
+      141,  141,  141,  141,  141,  141,  142,  186,  132,  132,
+      132,  132,  132,  132,  144,  142,  142,  142,  142,  142,
+      142,  147,  185,  144,  144,  144,  144,  144,  144,  184,
+      147,  147,  147,  147,  147,  147,  149,  149,  149,  149,
+      149,  183,  182,  181,  176,  172,  170,  164,  169,  163,
+
+      162,  161,  160,  262,  159,  149,  164,  164,  164,  164,
+      164,  164,  165,  262,  149,  149,  149,  149,  149,  149,
+      167,  165,  165,  165,  165,  165,  165,  262,  158,  167,
+      167,  167,  167,  167,  167,  171,  171,  171,  171,  171,
+      173,  171,  157,  155,  153,  151,  171,  148,  171,  173,
+      173,  173,  173,  173,  173,  174,  145,  139,  137,  133,
+      171,  175,  129,  128,  174,  174,  174,  174,  174,  174,
+      175,  175,  175,  175,  175,  175,  178,  297,  297,  297,
+      297,  297,  179,  127,  126,  178,  178,  178,  178,  178,
+      178,  179,  179,  179,  179,  179,  179,  189,  125,  124,
+
+      123,  122,  297,  190,  120,  119,  189,  189,  189,  189,
+      189,  189,  190,  190,  190,  190,  190,  190,  191,  118,
+      116,  115,  113,  112,  110,  109,  107,  191,  191,  191,
+      191,  191,  191,  196,  196,  196,  196,  196,  203,  196,
+      104,  102,  100,   91,  196,   85,  196,  203,  203,  203,
+      203,  203,  203,   78,   71,   70,   69,   68,  196,  197,
+      197,  197,  197,  197,  204,  197,   67,   66,   65,   64,
+      197,   63,  197,  204,  204,  204,  204,  204,  204,   51,
+       47,   46,   44,   38,  197,  201,  201,  201,  201,  201,
+       32,  201,   28,   25,   24,   20,  201,  201,  201,   17,
+
+       15,   14,   12,   10,  201,    9,    3,    0,    0,    0,
+      201,  205,    0,  201,  201,  201,  201,  201,  201,  206,
+      205,  205,  205,  205,  205,  205,  207,    0,  206,  206,
+      206,  206,  206,  206,  215,  207,  207,  207,  207,  207,
+      207,  216,    0,  215,  215,  215,  215,  215,  215,  217,
+      216,  216,  216,  216,  216,  216,    0,    0,  217,  217,
+      217,  217,  217,  217,  226,  226,  226,  226,  236,    0,
+      226,    0,    0,    0,    0,    0,    0,  236,  236,  236,
+      236,  236,  236,  226,    0,    0,    0,    0,    0,  226,
+        0,    0,  226,  226,  226,  226,  226,  226,  228,  228,
+
+      228,  228,  237,    0,    0,    0,    0,    0,    0,  228,
+        0,  237,  237,  237,  237,  237,  237,  228,    0,    0,
+        0,    0,    0,  228,    0,    0,  228,  228,  228,  228,
+      228,  228,  229,  229,  229,  229,  229,  238,  229,    0,
+        0,    0,    0,  229,    0,  229,  238,  238,  238,  238,
+      238,  238,    0,    0,    0,    0,    0,  229,  230,  230,
+      230,  230,  230,  239,  230,    0,    0,    0,    0,  230,
+        0,  230,  239,  239,  239,  239,  239,  239,    0,    0,
+        0,    0,    0,  230,  231,  231,  231,  231,  231,  240,
+      231,    0,    0,    0,    0,  231,    0,  231,  240,  240,
+
+      240,  240,  240,  240,    0,    0,    0,    0,    0,  231,
+      232,  232,  232,  232,  232,  246,  232,    0,    0,    0,
+        0,  232,    0,  232,  246,  246,  246,  246,  246,  246,
+        0,    0,    0,    0,    0,  232,  233,  233,  233,  233,
+      233,    0,  233,    0,    0,    0,    0,  233,    0,  233,
+      287,  287,  287,  287,  287,  233,  287,    0,    0,    0,
+        0,  233,    0,  287,  233,  233,  233,  233,  233,  233,
+      234,  234,  234,  234,  234,  287,  234,    0,    0,    0,
+        0,  234,  234,  234,    0,    0,    0,    0,    0,  234,
+        0,    0,    0,    0,    0,  234,  247,    0,  234,  234,
+
+      234,  234,  234,  234,  248,  247,  247,  247,  247,  247,
+      247,    0,    0,  248,  248,  248,  248,  248,  248,  260,
+      260,  260,  260,  260,    0,  260,    0,    0,    0,    0,
+        0,    0,  264,  264,  264,  264,  264,    0,  260,    0,
+        0,    0,    0,  264,  260,  264,    0,  260,  260,  260,
+      260,  260,  260,  261,  261,  261,  261,  264,    0,  261,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,  261,    0,    0,    0,    0,    0,  261,    0,
+        0,  261,  261,  261,  261,  261,  261,  265,  265,  265,
+      265,  265,    0,    0,    0,    0,    0,    0,  265,    0,
+
+        0,    0,    0,    0,    0,    0,  265,    0,    0,    0,
+        0,    0,  265,    0,    0,  265,  265,  265,  265,  265,
+      265,  266,  266,  266,  266,  267,    0,    0,    0,    0,
+        0,    0,  266,    0,  267,  267,  267,  267,  267,  267,
+      266,    0,    0,    0,    0,    0,  266,  269,    0,  266,
+      266,  266,  266,  266,  266,  270,  269,  269,  269,  269,
+      269,  269,  271,    0,  270,  270,  270,  270,  270,  270,
+      273,  271,  271,  271,  271,  271,  271,  279,    0,  273,
+      273,  273,  273,  273,  273,  290,  279,  279,  279,  279,
+      279,  279,    0,    0,  290,  290,  290,  290,  290,  290,
+
+      291,  291,  291,  291,  291,  294,    0,    0,    0,    0,
+        0,  291,    0,  291,  294,  294,  294,  294,  294,  294,
+      295,    0,    0,    0,    0,  291,  303,    0,    0,  295,
+      295,  295,  295,  295,  295,  303,  303,  303,  303,  303,
+      303,  304,    0,    0,    0,    0,    0,  305,    0,    0,
+      304,  304,  304,  304,  304,  304,  305,  305,  305,  305,
+      305,  305,  306,    0,    0,    0,    0,    0,  314,    0,
+        0,  306,  306,  306,  306,  306,  306,  314,  314,  314,
+      314,  314,  314,  315,    0,    0,    0,    0,    0,  316,
+        0,    0,  315,  315,  315,  315,  315,  315,  316,  316,
+
+      316,  316,  316,  316,  320,    0,    0,    0,    0,    0,
+      321,    0,    0,  320,  320,  320,  320,  320,  320,  321,
+      321,  321,  321,  321,  321,  322,    0,    0,    0,    0,
+        0,  326,    0,    0,  322,  322,  322,  322,  322,  322,
+      326,  326,  326,  326,  326,  326,  327,    0,    0,    0,
+        0,    0,    0,    0,    0,  327,  327,  327,  327,  327,
+      327,  331,    0,  331,  331,  331,  331,  331,  331,  332,
+        0,  332,  332,  333,    0,  333,  333,  333,  333,  333,
+      333,  334,    0,  334,  334,  335,  335,  335,  335,  335,
+      335,  336,  336,    0,  336,  336,  337,  337,  337,  337,
+
+      337,  337,  337,  337,  338,  338,  338,  338,  338,  338,
+      339,  339,  339,  339,  339,  339,  339,  339,  340,  340,
+      340,  340,  340,  340,  340,  340,  340,  341,  341,  342,
+      342,  342,  342,  342,  342,  343,    0,  343,  343,  344,
+      344,  344,  344,  344,  344,  345,  345,  345,  345,  345,
+      345,  345,  345,  345,  346,  346,  346,  346,  346,  346,
+      347,  347,    0,  347,  348,  348,  348,  348,  348,  348,
+      348,  348,  348,  349,  349,    0,  349,  350,  350,  350,
+        0,  350,  350,  350,  350,  351,  351,    0,  351,  352,
+        0,  352,  352,  352,  352,  352,  352,  353,    0,  353,
+
+      353,  353,  353,  353,  353,  354,  354,  354,  354,  354,
+      354,  354,  354,  355,  355,    0,  355,  356,  356,  356,
+      356,  356,  356,  356,  356,  357,  357,  357,  357,  357,
+      357,  357,  357,  358,  358,    0,  358,  330,  330,  330,
+      330,  330,  330,  330,  330,  330,  330,  330,  330,  330,
+      330,  330,  330,  330,  330,  330,  330,  330,  330,  330,
+      330,  330,  330,  330,  330,  330,  330,  330,  330,  330,
+      330,  330,  330,  330,  330,  330,  330,  330,  330,  330,
+      330,  330,  330,  330,  330,  330,  330,  330,  330,  330,
+      330,  330,  330,  330
+
+    } ;
+
+YY_DECL
+	{
+	register yy_state_type yy_current_state;
+	register unsigned short *yy_cp, *yy_bp;
+	register int yy_act;
+
+#line 25 "tokenizer.flex"
+
+
+#line 1009 "tok"
+
+	while ( 1 )		/* loops until end-of-file is reached */
+		{
+		yy_cp = yy_c_buf_p;
+
+		/* Support of yytext. */
+		*yy_cp = yy_hold_char;
+
+		/* yy_bp points to the position in yy_ch_buf of the start of
+		 * the current run.
+		 */
+		yy_bp = yy_cp;
+
+		yy_current_state = yy_start;
+yy_match:
+		do
+			{
+			register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
+			if ( yy_accept[yy_current_state] )
+				{
+				yy_last_accepting_state = yy_current_state;
+				yy_last_accepting_cpos = yy_cp;
+				}
+			while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+				{
+				yy_current_state = (int) yy_def[yy_current_state];
+				if ( yy_current_state >= 331 )
+					yy_c = yy_meta[(unsigned int) yy_c];
+				}
+			yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+			++yy_cp;
+			}
+		while ( yy_base[yy_current_state] != 1638 );
+
+yy_find_action:
+		yy_act = yy_accept[yy_current_state];
+		if ( yy_act == 0 )
+			{ /* have to back up */
+			yy_cp = yy_last_accepting_cpos;
+			yy_current_state = yy_last_accepting_state;
+			yy_act = yy_accept[yy_current_state];
+			}
+
+		YY_DO_BEFORE_ACTION;
+
+
+do_action:	/* This label is used only to access EOF actions. */
+
+
+		switch ( yy_act )
+	{ /* beginning of action switch */
+			case 0: /* must back up */
+			/* undo the effects of YY_DO_BEFORE_ACTION */
+			*yy_cp = yy_hold_char;
+			yy_cp = yy_last_accepting_cpos;
+			yy_current_state = yy_last_accepting_state;
+			goto yy_find_action;
+
+case 1:
+YY_RULE_SETUP
+#line 27 "tokenizer.flex"
+/* ignore comments */
+	YY_BREAK
+case 2:
+YY_RULE_SETUP
+#line 29 "tokenizer.flex"
+{yyTok = S; return yyTok;}
+	YY_BREAK
+case 3:
+YY_RULE_SETUP
+#line 31 "tokenizer.flex"
+{yyTok = SGML_CD; return yyTok;}
+	YY_BREAK
+case 4:
+YY_RULE_SETUP
+#line 32 "tokenizer.flex"
+{yyTok = SGML_CD; return yyTok;}
+	YY_BREAK
+case 5:
+YY_RULE_SETUP
+#line 33 "tokenizer.flex"
+{yyTok = INCLUDES; return yyTok;}
+	YY_BREAK
+case 6:
+YY_RULE_SETUP
+#line 34 "tokenizer.flex"
+{yyTok = DASHMATCH; return yyTok;}
+	YY_BREAK
+case 7:
+YY_RULE_SETUP
+#line 35 "tokenizer.flex"
+{yyTok = BEGINSWITH; return yyTok;}
+	YY_BREAK
+case 8:
+YY_RULE_SETUP
+#line 36 "tokenizer.flex"
+{yyTok = ENDSWITH; return yyTok;}
+	YY_BREAK
+case 9:
+YY_RULE_SETUP
+#line 37 "tokenizer.flex"
+{yyTok = CONTAINS; return yyTok;}
+	YY_BREAK
+case 10:
+YY_RULE_SETUP
+#line 39 "tokenizer.flex"
+{yyTok = STRING; return yyTok;}
+	YY_BREAK
+case 11:
+YY_RULE_SETUP
+#line 41 "tokenizer.flex"
+{yyTok = IDENT; return yyTok;}
+	YY_BREAK
+case 12:
+YY_RULE_SETUP
+#line 43 "tokenizer.flex"
+{yyTok = NTH; return yyTok;}
+	YY_BREAK
+case 13:
+YY_RULE_SETUP
+#line 45 "tokenizer.flex"
+{yyTok = HASH; return yyTok;}
+	YY_BREAK
+case 14:
+YY_RULE_SETUP
+#line 47 "tokenizer.flex"
+{yyTok = IMPORT_SYM; return yyTok;}
+	YY_BREAK
+case 15:
+YY_RULE_SETUP
+#line 48 "tokenizer.flex"
+{yyTok = PAGE_SYM; return yyTok;}
+	YY_BREAK
+case 16:
+YY_RULE_SETUP
+#line 49 "tokenizer.flex"
+{yyTok = MEDIA_SYM; return yyTok;}
+	YY_BREAK
+case 17:
+YY_RULE_SETUP
+#line 50 "tokenizer.flex"
+{yyTok = FONT_FACE_SYM; return yyTok;}
+	YY_BREAK
+case 18:
+YY_RULE_SETUP
+#line 51 "tokenizer.flex"
+{yyTok = CHARSET_SYM; return yyTok;}
+	YY_BREAK
+case 19:
+YY_RULE_SETUP
+#line 52 "tokenizer.flex"
+{yyTok = NAMESPACE_SYM; return yyTok; }
+	YY_BREAK
+case 20:
+YY_RULE_SETUP
+#line 53 "tokenizer.flex"
+{yyTok = KHTML_RULE_SYM; return yyTok; }
+	YY_BREAK
+case 21:
+YY_RULE_SETUP
+#line 54 "tokenizer.flex"
+{yyTok = KHTML_DECLS_SYM; return yyTok; }
+	YY_BREAK
+case 22:
+YY_RULE_SETUP
+#line 55 "tokenizer.flex"
+{yyTok = KHTML_VALUE_SYM; return yyTok; }
+	YY_BREAK
+case 23:
+YY_RULE_SETUP
+#line 57 "tokenizer.flex"
+{yyTok = IMPORTANT_SYM; return yyTok;}
+	YY_BREAK
+case 24:
+YY_RULE_SETUP
+#line 59 "tokenizer.flex"
+{yyTok = EMS; return yyTok;}
+	YY_BREAK
+case 25:
+YY_RULE_SETUP
+#line 60 "tokenizer.flex"
+{yyTok = QEMS; return yyTok;} /* quirky ems */
+	YY_BREAK
+case 26:
+YY_RULE_SETUP
+#line 61 "tokenizer.flex"
+{yyTok = EXS; return yyTok;}
+	YY_BREAK
+case 27:
+YY_RULE_SETUP
+#line 62 "tokenizer.flex"
+{yyTok = PXS; return yyTok;}
+	YY_BREAK
+case 28:
+YY_RULE_SETUP
+#line 63 "tokenizer.flex"
+{yyTok = CMS; return yyTok;}
+	YY_BREAK
+case 29:
+YY_RULE_SETUP
+#line 64 "tokenizer.flex"
+{yyTok = MMS; return yyTok;}
+	YY_BREAK
+case 30:
+YY_RULE_SETUP
+#line 65 "tokenizer.flex"
+{yyTok = INS; return yyTok;}
+	YY_BREAK
+case 31:
+YY_RULE_SETUP
+#line 66 "tokenizer.flex"
+{yyTok = PTS; return yyTok;}
+	YY_BREAK
+case 32:
+YY_RULE_SETUP
+#line 67 "tokenizer.flex"
+{yyTok = PCS; return yyTok;}
+	YY_BREAK
+case 33:
+YY_RULE_SETUP
+#line 68 "tokenizer.flex"
+{yyTok = DEGS; return yyTok;}
+	YY_BREAK
+case 34:
+YY_RULE_SETUP
+#line 69 "tokenizer.flex"
+{yyTok = RADS; return yyTok;}
+	YY_BREAK
+case 35:
+YY_RULE_SETUP
+#line 70 "tokenizer.flex"
+{yyTok = GRADS; return yyTok;}
+	YY_BREAK
+case 36:
+YY_RULE_SETUP
+#line 71 "tokenizer.flex"
+{yyTok = MSECS; return yyTok;}
+	YY_BREAK
+case 37:
+YY_RULE_SETUP
+#line 72 "tokenizer.flex"
+{yyTok = SECS; return yyTok;}
+	YY_BREAK
+case 38:
+YY_RULE_SETUP
+#line 73 "tokenizer.flex"
+{yyTok = HERZ; return yyTok;}
+	YY_BREAK
+case 39:
+YY_RULE_SETUP
+#line 74 "tokenizer.flex"
+{yyTok = KHERZ; return yyTok;}
+	YY_BREAK
+case 40:
+YY_RULE_SETUP
+#line 75 "tokenizer.flex"
+{yyTok = DIMEN; return yyTok;}
+	YY_BREAK
+case 41:
+YY_RULE_SETUP
+#line 76 "tokenizer.flex"
+{yyTok = PERCENTAGE; return yyTok;}
+	YY_BREAK
+case 42:
+YY_RULE_SETUP
+#line 77 "tokenizer.flex"
+{yyTok = INTEGER; return yyTok;}
+	YY_BREAK
+case 43:
+YY_RULE_SETUP
+#line 78 "tokenizer.flex"
+{yyTok = FLOAT; return yyTok;}
+	YY_BREAK
+case 44:
+YY_RULE_SETUP
+#line 81 "tokenizer.flex"
+{yyTok = NOTFUNCTION; return yyTok;}
+	YY_BREAK
+case 45:
+YY_RULE_SETUP
+#line 82 "tokenizer.flex"
+{yyTok = URI; return yyTok;}
+	YY_BREAK
+case 46:
+YY_RULE_SETUP
+#line 83 "tokenizer.flex"
+{yyTok = URI; return yyTok;}
+	YY_BREAK
+case 47:
+YY_RULE_SETUP
+#line 84 "tokenizer.flex"
+{yyTok = FUNCTION; return yyTok;}
+	YY_BREAK
+case 48:
+YY_RULE_SETUP
+#line 86 "tokenizer.flex"
+{yyTok = UNICODERANGE; return yyTok;}
+	YY_BREAK
+case 49:
+YY_RULE_SETUP
+#line 87 "tokenizer.flex"
+{yyTok = UNICODERANGE; return yyTok;}
+	YY_BREAK
+case 50:
+YY_RULE_SETUP
+#line 89 "tokenizer.flex"
+{yyTok = *yytext; return yyTok;}
+	YY_BREAK
+case 51:
+YY_RULE_SETUP
+#line 91 "tokenizer.flex"
+ECHO;
+	YY_BREAK
+#line 1347 "tok"
+case YY_STATE_EOF(INITIAL):
+	yyterminate();
+
+	case YY_END_OF_BUFFER:
+        yy_c_buf_p = yytext;
+        yy_act = YY_STATE_EOF(YY_START);
+        goto do_action;
+
+	default:
+		YY_FATAL_ERROR(
+			"fatal flex scanner internal error--no action found" );
+	} /* end of action switch */
+		} /* end of scanning one token */
+} /* end of yylex */
diff --git a/tdehtml/css/tokenizer.flex b/tdehtml/css/tokenizer.flex
new file mode 100644
index 000000000..76fcadb7c
--- /dev/null
+++ b/tdehtml/css/tokenizer.flex
@@ -0,0 +1,92 @@
+%option case-insensitive
+%option noyywrap
+%option 8bit
+
+h               [0-9a-fA-F]
+nonascii        [\200-\377]
+unicode         \\{h}{1,6}[ \t\r\n\f]?
+escape          {unicode}|\\[ -~\200-\377]
+nmstart         [_a-zA-Z]|{nonascii}|{escape}
+nmchar          [_a-zA-Z0-9-]|{nonascii}|{escape}
+string1         \"([\t !#$%&(-~]|\\{nl}|\'|{nonascii}|{escape})*\"
+string2         \'([\t !#$%&(-~]|\\{nl}|\"|{nonascii}|{escape})*\'
+
+ident           -?{nmstart}{nmchar}*
+name            {nmchar}+
+num             [0-9]+|[0-9]*"."[0-9]+
+intnum          [0-9]+
+string          {string1}|{string2}
+url             ([!#$%&*-~]|{nonascii}|{escape})*
+w               [ \t\r\n\f]*
+nl              \n|\r\n|\r|\f
+range           \?{1,6}|{h}(\?{0,5}|{h}(\?{0,4}|{h}(\?{0,3}|{h}(\?{0,2}|{h}(\??|{h})))))
+nth             (-?[0-9]*n[\+-][0-9]+)|(-?[0-9]*n)
+
+%%
+
+\/\*[^*]*\*+([^/*][^*]*\*+)*\/  /* ignore comments */
+
+[ \t\r\n\f]+            {yyTok = S; return yyTok;}
+
+"<!--"                  {yyTok = SGML_CD; return yyTok;}
+"-->"                   {yyTok = SGML_CD; return yyTok;}
+"~="                    {yyTok = INCLUDES; return yyTok;}
+"|="                    {yyTok = DASHMATCH; return yyTok;}
+"^="                    {yyTok = BEGINSWITH; return yyTok;}
+"$="                    {yyTok = ENDSWITH; return yyTok;}
+"*="                    {yyTok = CONTAINS; return yyTok;}
+
+{string}                {yyTok = STRING; return yyTok;}
+
+{ident}                 {yyTok = IDENT; return yyTok;}
+
+{nth}                   {yyTok = NTH; return yyTok;}
+
+"#"{name}               {yyTok = HASH; return yyTok;}
+
+"@import"               {yyTok = IMPORT_SYM; return yyTok;}
+"@page"                 {yyTok = PAGE_SYM; return yyTok;}
+"@media"                {yyTok = MEDIA_SYM; return yyTok;}
+"@font-face"            {yyTok = FONT_FACE_SYM; return yyTok;}
+"@charset"              {yyTok = CHARSET_SYM; return yyTok;}
+"@namespace"		{yyTok = NAMESPACE_SYM; return yyTok; }
+"@-tdehtml-rule"    {yyTok = KHTML_RULE_SYM; return yyTok; }
+"@-tdehtml-decls"   {yyTok = KHTML_DECLS_SYM; return yyTok; }
+"@-tdehtml-value"   {yyTok = KHTML_VALUE_SYM; return yyTok; }
+
+"!"{w}"important"         {yyTok = IMPORTANT_SYM; return yyTok;}
+
+{num}em                 {yyTok = EMS; return yyTok;}
+{num}__qem              {yyTok = QEMS; return yyTok;} /* quirky ems */
+{num}ex                 {yyTok = EXS; return yyTok;}
+{num}px                 {yyTok = PXS; return yyTok;}
+{num}cm                 {yyTok = CMS; return yyTok;}
+{num}mm                 {yyTok = MMS; return yyTok;}
+{num}in                 {yyTok = INS; return yyTok;}
+{num}pt                 {yyTok = PTS; return yyTok;}
+{num}pc                 {yyTok = PCS; return yyTok;}
+{num}deg                {yyTok = DEGS; return yyTok;}
+{num}rad                {yyTok = RADS; return yyTok;}
+{num}grad               {yyTok = GRADS; return yyTok;}
+{num}ms                 {yyTok = MSECS; return yyTok;}
+{num}s                  {yyTok = SECS; return yyTok;}
+{num}Hz                 {yyTok = HERZ; return yyTok;}
+{num}kHz                {yyTok = KHERZ; return yyTok;}
+{num}{ident}            {yyTok = DIMEN; return yyTok;}
+{num}%                  {yyTok = PERCENTAGE; return yyTok;}
+{intnum}                {yyTok = INTEGER; return yyTok;}
+{num}                   {yyTok = FLOAT; return yyTok;}
+
+
+"not("                  {yyTok = NOTFUNCTION; return yyTok;}
+"url("{w}{string}{w}")" {yyTok = URI; return yyTok;}
+"url("{w}{url}{w}")"    {yyTok = URI; return yyTok;}
+{ident}"("              {yyTok = FUNCTION; return yyTok;}
+
+U\+{range}              {yyTok = UNICODERANGE; return yyTok;}
+U\+{h}{1,6}-{h}{1,6}    {yyTok = UNICODERANGE; return yyTok;}
+
+.                       {yyTok = *yytext; return yyTok;}
+
+%%
+