diff options
Diffstat (limited to 'khtml/css/cssstyleselector.cpp')
| -rw-r--r-- | khtml/css/cssstyleselector.cpp | 4190 |
1 files changed, 4190 insertions, 0 deletions
diff --git a/khtml/css/cssstyleselector.cpp b/khtml/css/cssstyleselector.cpp new file mode 100644 index 000000000..235a2cf20 --- /dev/null +++ b/khtml/css/cssstyleselector.cpp @@ -0,0 +1,4190 @@ +/** + * 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 "khtml_factory.h" +#include "khtmlpart_p.h" +using namespace khtml; +using namespace DOM; + +#include "css/cssproperties.h" +#include "css/cssvalues.h" + +#include "misc/khtmllayout.h" +#include "khtml_settings.h" +#include "misc/htmlhashes.h" +#include "misc/helper.h" +#include "misc/loader.h" + +#include "rendering/font.h" + +#include "khtmlview.h" +#include "khtml_part.h" + +#include <kstandarddirs.h> +#include <kcharsets.h> +#include <kglobal.h> +#include <kconfig.h> +#include <qfile.h> +#include <qvaluelist.h> +#include <qstring.h> +#include <qtooltip.h> +#include <kdebug.h> +#include <kurl.h> +#include <assert.h> +#include <qpaintdevicemetrics.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;\ +} + +namespace khtml { + +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, QString 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() : QString("all"); + + selectors = 0; + selectorCache = 0; + properties = 0; + userStyle = 0; + userSheet = 0; + paintDeviceMetrics = doc->paintDeviceMetrics(); + + if(paintDeviceMetrics) // this may be null, not everyone uses khtmlview (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(); + + + QPtrListIterator<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( QString::null ); + u.setRef( QString::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( QString::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; + + { + QFile f(locate( "data", "khtml/css/html4.css" ) ); + f.open(IO_ReadOnly); + + QCString file( f.size()+1 ); + int readbytes = f.readBlock( file.data(), f.size() ); + f.close(); + if ( readbytes >= 0 ) + file[readbytes] = '\0'; + + QString style = QString::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" ); + } + { + QFile f(locate( "data", "khtml/css/quirks.css" ) ); + f.open(IO_ReadOnly); + + QCString file( f.size()+1 ); + int readbytes = f.readBlock( file.data(), f.size() ); + f.close(); + if ( readbytes >= 0 ) + file[readbytes] = '\0'; + + QString style = QString::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(QPaintDeviceMetrics* paintDeviceMetrics, int zoomFactor) +{ + computeFontSizesFor(paintDeviceMetrics, zoomFactor, m_fontSizes, false); + computeFontSizesFor(paintDeviceMetrics, zoomFactor, m_fixedFontSizes, true); +} + +void CSSStyleSelector::computeFontSizesFor(QPaintDeviceMetrics* paintDeviceMetrics, int zoomFactor, QValueVector<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 (!khtml::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. + Q_UINT16 cssTagId = localNamePart(element->id()); + int smatch = 0; + int schecked = 0; + + for ( unsigned int i = 0; i < selectors_size; i++ ) { + Q_UINT16 tag = localNamePart(selectors[i]->tag); + if ( cssTagId == tag || tag == anyLocalName ) { + ++schecked; + + checkSelector( i, e ); + + if ( selectorCache[i].state == Applies ) { + ++smatch; + +// qDebug("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 ); + +// qDebug( "styleForElement( %s )", e->tagName().string().latin1() ); +// qDebug( "%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; + //qDebug("%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; + + QPtrList<CSSProperty>* values = decl ? decl->values() : 0; + QPtrList<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(QString &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; + } + QConstString cu(attr.unicode(), attr.length()); + QString 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 QString& 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; + //qDebug( "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(); + Q_UINT16 localName = localNamePart(eltID); + Q_UINT16 ns = namespacePart(eltID); + Q_UINT16 selLocalName = localNamePart(sel->tag); + Q_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; + + QChar* sel_uc = sel->value.unicode(); + QChar* val_uc = value->unicode(); + + QConstString sel_str(sel_uc, sel_len); + QConstString 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; + QConstString val_str(value->unicode(), value->length()); + QConstString 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; + QConstString val_str(value->unicode(), value->length()); + QConstString 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; + QConstString val_str(value->unicode(), value->length()); + QConstString 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; + QConstString val_str(value->unicode(), value->length()); + QConstString sel_str(sel->value.unicode(), sel->value.length()); + const QString& str = val_str.string(); + const QString& 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; + + QString langAttr = value.string(); + QString 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(); + QString 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. + + QPtrList<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() + : QPtrList<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); + QPtrList<CSSSelector> *s = r->selector(); + for(int j = 0; j < (int)s->count(); j++) + { + CSSOrderedRule *rule = new CSSOrderedRule(r, s->at(j), count()); + QPtrList<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 ); + + QPtrList<CSSSelector> *s = styleRule->selector(); + for( int j = 0; j < ( int ) s->count(); j++ ) + { + CSSOrderedRule *orderedRule = new CSSOrderedRule( + styleRule, s->at( j ), count() ); + QPtrList<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( QPtrList<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 +// qDebug("merged one selector"); + propList->append(r->rule->declaration(), selectorNum, r->selector->specificity(), regular, important ); + r = next(); + } +} + +// ------------------------------------------------------------------------- + +int CSSOrderedPropertyList::compareItems(QPtrCollection::Item i1, QPtrCollection::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 ) +{ + QPtrList<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; + } + + QPtrList<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, QPaintDeviceMetrics *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; +QPalette::ColorGroup group; +QColorGroup::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", QPalette::Active, QColorGroup::Light }, + // Active window caption. + { CSS_VAL_ACTIVECAPTION, wmgroup, "background", QPalette::Active, QColorGroup::Text }, + // Text in caption, size box, and scrollbar arrow box. + { CSS_VAL_CAPTIONTEXT, wmgroup, "activeForeground", QPalette::Active, QColorGroup::Text }, + // Face color for three-dimensional display elements. + { CSS_VAL_BUTTONFACE, wmgroup, 0, QPalette::Inactive, QColorGroup::Button }, + // Dark shadow for three-dimensional display elements (for edges facing away from the light source). + { CSS_VAL_BUTTONHIGHLIGHT, wmgroup, 0, QPalette::Inactive, QColorGroup::Light }, + // Shadow color for three-dimensional display elements. + { CSS_VAL_BUTTONSHADOW, wmgroup, 0, QPalette::Inactive, QColorGroup::Shadow }, + // Text on push buttons. + { CSS_VAL_BUTTONTEXT, wmgroup, "buttonForeground", QPalette::Inactive, QColorGroup::ButtonText }, + // Dark shadow for three-dimensional display elements. + { CSS_VAL_THREEDDARKSHADOW, wmgroup, 0, QPalette::Inactive, QColorGroup::Dark }, + // Face color for three-dimensional display elements. + { CSS_VAL_THREEDFACE, wmgroup, 0, QPalette::Inactive, QColorGroup::Button }, + // Highlight color for three-dimensional display elements. + { CSS_VAL_THREEDHIGHLIGHT, wmgroup, 0, QPalette::Inactive, QColorGroup::Light }, + // Light color for three-dimensional display elements (for edges facing the light source). + { CSS_VAL_THREEDLIGHTSHADOW, wmgroup, 0, QPalette::Inactive, QColorGroup::Midlight }, + // Dark shadow for three-dimensional display elements. + { CSS_VAL_THREEDSHADOW, wmgroup, 0, QPalette::Inactive, QColorGroup::Shadow }, + + // Inactive window border. + { CSS_VAL_INACTIVEBORDER, wmgroup, "background", QPalette::Disabled, QColorGroup::Background }, + // Inactive window caption. + { CSS_VAL_INACTIVECAPTION, wmgroup, "inactiveBackground", QPalette::Disabled, QColorGroup::Background }, + // Color of text in an inactive caption. + { CSS_VAL_INACTIVECAPTIONTEXT, wmgroup, "inactiveForeground", QPalette::Disabled, QColorGroup::Text }, + { CSS_VAL_GRAYTEXT, wmgroup, 0, QPalette::Disabled, QColorGroup::Text }, + + // Menu background + { CSS_VAL_MENU, generalgroup, "background", QPalette::Inactive, QColorGroup::Background }, + // Text in menus + { CSS_VAL_MENUTEXT, generalgroup, "foreground", QPalette::Inactive, QColorGroup::Background }, + + // Text of item(s) selected in a control. + { CSS_VAL_HIGHLIGHT, generalgroup, "selectBackground", QPalette::Inactive, QColorGroup::Background }, + + // Text of item(s) selected in a control. + { CSS_VAL_HIGHLIGHTTEXT, generalgroup, "selectForeground", QPalette::Inactive, QColorGroup::Background }, + + // Background color of multiple document interface. + { CSS_VAL_APPWORKSPACE, generalgroup, "background", QPalette::Inactive, QColorGroup::Text }, + + // Scroll bar gray area. + { CSS_VAL_SCROLLBAR, generalgroup, "background", QPalette::Inactive, QColorGroup::Background }, + + // Window background. + { CSS_VAL_WINDOW, generalgroup, "windowBackground", QPalette::Inactive, QColorGroup::Background }, + // Window frame. + { CSS_VAL_WINDOWFRAME, generalgroup, "windowBackground", QPalette::Inactive, QColorGroup::Background }, + // WindowText + { CSS_VAL_WINDOWTEXT, generalgroup, "windowForeground", QPalette::Inactive, QColorGroup::Text }, + { CSS_VAL_TEXT, generalgroup, 0, QPalette::Inactive, QColorGroup::Text }, + { 0, 0, 0, QPalette::NColorGroups, QColorGroup::NColorRoles } +}; + +static QColor 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 QToolTip::palette().inactive().background(); + else if ( css_value == CSS_VAL_INFOTEXT ) + return QToolTip::palette().inactive().foreground(); + else if ( css_value == CSS_VAL_BACKGROUND ) { + KConfig bckgrConfig("kdesktoprc", true, false); // No multi-screen support + bckgrConfig.setGroup("Desktop0"); + // Desktop background. + return bckgrConfig.readColorEntry("Color1", &qApp->palette().disabled().background()); + } + return QColor(); + } +#endif + + const QPalette &pal = qApp->palette(); + QColor c = pal.color( uicol->group, uicol->role ); +#ifndef APPLE_CHANGES + if ( uicol->configEntry ) { + KConfig *globalConfig = KGlobal::config(); + globalConfig->setGroup( uicol->configGroup ); + c = globalConfig->readColorEntry( uicol->configEntry, &c ); + } +#endif + + return c; +} + +static inline int nextFontSize(const QValueVector<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 = QFont::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 = QFont::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 = QFont::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: + { + QColor 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 = QColor(); + else + col = colorForCSSValue( ident ); + } else if ( primitiveValue->primitiveType() == CSSPrimitiveValue::CSS_RGBCOLOR ) { +#ifndef APPLE_CHANGES + if(qAlpha(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(QPalette::Active, QColorGroup::Button, col); + style->setPaletteColor(QPalette::Inactive, QColorGroup::Button, col); + break; + case CSS_PROP_SCROLLBAR_SHADOW_COLOR: + style->setPaletteColor(QPalette::Active, QColorGroup::Shadow, col); + style->setPaletteColor(QPalette::Inactive, QColorGroup::Shadow, col); + break; + case CSS_PROP_SCROLLBAR_HIGHLIGHT_COLOR: + style->setPaletteColor(QPalette::Active, QColorGroup::Light, col); + style->setPaletteColor(QPalette::Inactive, QColorGroup::Light, col); + break; + case CSS_PROP_SCROLLBAR_3DLIGHT_COLOR: + break; + case CSS_PROP_SCROLLBAR_DARKSHADOW_COLOR: + style->setPaletteColor(QPalette::Active, QColorGroup::Dark, col); + style->setPaletteColor(QPalette::Inactive, QColorGroup::Dark, col); + break; + case CSS_PROP_SCROLLBAR_TRACK_COLOR: + style->setPaletteColor(QPalette::Active, QColorGroup::Mid, col); + style->setPaletteColor(QPalette::Inactive, QColorGroup::Mid, col); + style->setPaletteColor(QPalette::Active, QColorGroup::Background, col); + style->setPaletteColor(QPalette::Inactive, QColorGroup::Background, col); + // fall through + case CSS_PROP_SCROLLBAR_BASE_COLOR: + style->setPaletteColor(QPalette::Active, QColorGroup::Base, col); + style->setPaletteColor(QPalette::Inactive, QColorGroup::Base, col); + break; + case CSS_PROP_SCROLLBAR_ARROW_COLOR: + style->setPaletteColor(QPalette::Active, QColorGroup::ButtonText, col); + style->setPaletteColor(QPalette::Inactive, QColorGroup::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()) { + khtml::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 QValueVector<int>& fontSizes = (fontDef.genericFamily == FontDef::eMonospace) ? + m_fixedFontSizes : m_fontSizes; +#else + const QValueVector<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 ( !khtml::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 ( !khtml::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 = QString::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); + QString 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(QColor()); // Reset to invalid color so currentColor is used instead. + style->setBorderBottomColor(QColor()); + style->setBorderLeftColor(QColor()); + style->setBorderRightColor(QColor()); + } + } + 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; + QColor col = khtml::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 "-khtml-" 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; + } + } + 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 khtml |