cssstyleselector.cpp

来自「monqueror一个很具有参考价值的源玛」· C++ 代码 · 共 1,977 行 · 第 1/5 页

// 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_TEXT_DECORATION_COLOR:
    {
        MGColor col;
        if(value->valueType() == CSSValue::CSS_INHERIT)
        {
            switch(prop->m_id)
            {
            case CSS_PROP_BACKGROUND_COLOR:
                style->setBackgroundColor(e->parentNode()->style()->backgroundColor()); break;
            case CSS_PROP_BORDER_TOP_COLOR:
                style->setBorderTopColor(e->parentNode()->style()->borderTopColor()); break;
            case CSS_PROP_BORDER_RIGHT_COLOR:
                style->setBorderRightColor(e->parentNode()->style()->borderRightColor()); break;
            case CSS_PROP_BORDER_BOTTOM_COLOR:
                style->setBorderBottomColor(e->parentNode()->style()->borderBottomColor()); break;
            case CSS_PROP_BORDER_LEFT_COLOR:
                style->setBorderLeftColor(e->parentNode()->style()->borderLeftColor()); break;
            case CSS_PROP_COLOR:
                style->setColor(e->parentNode()->style()->color()); break;
            case CSS_PROP_OUTLINE_COLOR:
            default:
                // ###
                break;
            }
            return;
        }
        if(!primitiveValue) return;

        if(primitiveValue->primitiveType() == CSSPrimitiveValue::CSS_RGBCOLOR)
            col = primitiveValue->getRGBColorValue()->color();
        else
            return;
        //kdDebug( 6080 ) << "applying color " << col.isValid() << endl;
        switch(prop->m_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_TEXT_DECORATION_COLOR:
            style->setTextDecorationColor(col); break;
        case CSS_PROP_OUTLINE_COLOR:
            // ###
        default:
            return;
        }
        return;
    }
    break;
// uri || inherit
    case CSS_PROP_BACKGROUND_IMAGE:
    {
        if(value->valueType() == CSSValue::CSS_INHERIT)
        {
            if(!e->parentNode()) return;
            style->setBackgroundImage(e->parentNode()->style()->backgroundImage());
            break;
        }
        if(!primitiveValue) return;
        CSSImageValueImpl *image = static_cast<CSSImageValueImpl *>(primitiveValue);
        style->setBackgroundImage(image->image());
        //kdDebug( 6080 ) << "setting image in style to " << image->image() << endl;
        break;
    }
    case CSS_PROP_CUE_AFTER:
    case CSS_PROP_CUE_BEFORE:
        break;
    case CSS_PROP_LIST_STYLE_IMAGE:
    {
        if(value->valueType() == CSSValue::CSS_INHERIT)
        {
            if(!e->parentNode()) return;
            style->setListStyleImage(e->parentNode()->style()->listStyleImage());
            break;
        }
        if(!primitiveValue) return;
        CSSImageValueImpl *image = static_cast<CSSImageValueImpl *>(primitiveValue);
        style->setListStyleImage(image->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(value->valueType() == CSSValue::CSS_INHERIT)
        {
            switch(prop->m_id)
            {
            case CSS_PROP_BORDER_TOP_WIDTH:
                style->setBorderTopWidth(e->parentNode()->style()->borderTopWidth()); break;
            case CSS_PROP_BORDER_RIGHT_WIDTH:
                style->setBorderRightWidth(e->parentNode()->style()->borderRightWidth()); break;
            case CSS_PROP_BORDER_BOTTOM_WIDTH:
                style->setBorderBottomWidth(e->parentNode()->style()->borderBottomWidth()); break;
            case CSS_PROP_BORDER_LEFT_WIDTH:
                style->setBorderLeftWidth(e->parentNode()->style()->borderLeftWidth()); break;
            case CSS_PROP_OUTLINE_WIDTH:
                // ###
            default:
                // ###
                break;
            }
            return;
        }
        if(!primitiveValue) break;
        short width = 3; // medium is default value
        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:
            width = computeLength(primitiveValue, style, part);
            break;
        default:
            return;
        }
        if(width < 0) return;
        switch(prop->m_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:
            // ###
            break;
        default:
            return;
        }
        return;
    }

    case CSS_PROP_MARKER_OFFSET:
    case CSS_PROP_LETTER_SPACING:
    case CSS_PROP_WORD_SPACING:
    {
        if(value->valueType() == CSSValue::CSS_INHERIT)
        {
            if(!e->parentNode()) return;
            switch(prop->m_id)
            {
            case CSS_PROP_MARKER_OFFSET:
                // ###
                break;
            case CSS_PROP_LETTER_SPACING:
                style->setLetterSpacing(e->parentNode()->style()->letterSpacing()); break;
            case CSS_PROP_WORD_SPACING:
                style->setWordSpacing(e->parentNode()->style()->wordSpacing()); break;
            default:
                // ###
                break;
            }
            return;
        }
        if(!primitiveValue) return;
        int width = computeLength(primitiveValue, style, part);
// reason : letter or word spacing may be negative.
//      if( width < 0 ) return;
        switch(prop->m_id)
        {
        case CSS_PROP_LETTER_SPACING:
            style->setLetterSpacing(width);
            break;
        case CSS_PROP_WORD_SPACING:
            style->setWordSpacing(width);
            break;
            // ### needs the definitions in renderstyle
        case CSS_PROP_MARKER_OFFSET:
        default:
            return;
        }
    }

// length, percent
    case CSS_PROP_MAX_WIDTH:
        // +none +inherit
        if(primitiveValue && primitiveValue->getIdent() == CSS_VAL_NONE)
            apply = true;
    case CSS_PROP_BOTTOM:
    case CSS_PROP_TOP:
    case CSS_PROP_LEFT:
    case CSS_PROP_RIGHT:
    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(prop->m_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(value->valueType() == CSSValue::CSS_INHERIT) {
            if(!e->parentNode()) return;
            switch(prop->m_id)
                {
                case CSS_PROP_MAX_WIDTH:
                    style->setMaxWidth(e->parentNode()->style()->maxWidth()); break;
                case CSS_PROP_BOTTOM:
                    style->setBottom(e->parentNode()->style()->bottom()); break;
                case CSS_PROP_TOP:
                    style->setTop(e->parentNode()->style()->top()); break;
                case CSS_PROP_LEFT:
                    style->setLeft(e->parentNode()->style()->left()); break;
                case CSS_PROP_RIGHT:
                    style->setRight(e->parentNode()->style()->right()); break;
                case CSS_PROP_WIDTH:
                    style->setWidth(e->parentNode()->style()->width()); break;
                case CSS_PROP_MIN_WIDTH:
                    style->setMinWidth(e->parentNode()->style()->minWidth()); break;
                case CSS_PROP_PADDING_TOP:
                    style->setPaddingTop(e->parentNode()->style()->paddingTop()); break;
                case CSS_PROP_PADDING_RIGHT:
                    style->setPaddingRight(e->parentNode()->style()->paddingRight()); break;
                case CSS_PROP_PADDING_BOTTOM:
                    style->setPaddingBottom(e->parentNode()->style()->paddingBottom()); break;
                case CSS_PROP_PADDING_LEFT:
                    style->setPaddingLeft(e->parentNode()->style()->paddingLeft()); break;
                case CSS_PROP_MARGIN_TOP:
                    style->setMarginTop(e->parentNode()->style()->marginTop()); break;
                case CSS_PROP_MARGIN_RIGHT:
                    style->setMarginRight(e->parentNode()->style()->marginRight()); break;
                case CSS_PROP_MARGIN_BOTTOM:
                    style->setMarginBottom(e->parentNode()->style()->marginBottom()); break;
                case CSS_PROP_MARGIN_LEFT:
                    style->setMarginLeft(e->parentNode()->style()->marginLeft()); break;
                case CSS_PROP_TEXT_INDENT:
                    style->setTextIndent(e->parentNode()->style()->textIndent()); break;
                default:
                    return;
                }
        } else if(primitiveValue && !apply) {
            int type = primitiveValue->primitiveType();
            if(type > CSSPrimitiveValue::CSS_PERCENTAGE && type < CSSPrimitiveValue::CSS_DEG)
                l = Length(computeLength(primitiveValue, style, part), Fixed);
            else if(type == CSSPrimitiveValue::CSS_PERCENTAGE)
                l = Length((int)primitiveValue->getFloatValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);
            else
                return;
            apply = true;
        }
        if(!apply) return;
        switch(prop->m_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:
                return;
            }
    }

    case CSS_PROP_MAX_HEIGHT:
        // +inherit +none !can be calculted directly!
        if(primitiveValue && primitiveValue->getIdent() == CSS_VAL_NONE)
            apply = true;
    case CSS_PROP_HEIGHT:
    case CSS_PROP_MIN_HEIGHT:
        // +inherit +auto !can be calculted directly!
        if(!prop->m_id == CSS_PROP_MAX_HEIGHT && primitiveValue &&
           primitiveValue->getIdent() == CSS_VAL_AUTO)
            apply = true;
        if(value->valueType() == CSSValue::CSS_INHERIT)
        {
            if(!e->parentNode()) return;
            switch(prop->m_id)
                {
                case CSS_PROP_MAX_HEIGHT:
                    style->setMaxHeight(e->parentNode()->style()->maxHeight()); break;
                case CSS_PROP_HEIGHT:
                    style->setHeight(e->parentNode()->style()->height()); break;
                case CSS_PROP_MIN_HEIGHT:
                    style->setMinHeight(e->parentNode()->style()->minHeight()); break;
                default:
                    return;
                }
            return;
        }
        if(primitiveValue && !apply)
        {
            int type = primitiveValue->primitiveType();
            if(type > CSSPrimitiveValue::CSS_PERCENTAGE && type < CSSPrimitiveValue::CSS_DEG)
                l = Length(computeLength(primitiveValue, style, part), Fixed);
            else if(type == CSSPrimitiveValue::CSS_PERCENTAGE)
            {
                // ### compute from parents height!!!
                l = Length((int)primitiveValue->getFloatValue(CSSPrimitiveValue::CSS_PERCENTAGE), Percent);
            }
            else
                return;
            apply = true;
        }
        if(!apply) return;
        switch(prop->m_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:
        if(value->valueType() == CSSValue::CSS_INHERIT)
        {
            if(!e->parentNode()) return;
            style->setVerticalAlign(e->parentNode()->style()->verticalAlign());
            return;
        }
        if(!primitiveValue) return;
        if(primitiveValue->getIdent())
        {
            khtml::EVerticalAlign align;
            switch(primitiveValue->getIdent())