cssstyleselector.cpp

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

        break;
    }

    case CSS_PROP_EMPTY_CELLS:
        break;
    case CSS_PROP_FLOAT:
    {
        if(value->valueType() == CSSValue::CSS_INHERIT)
        {
            if(!e->parentNode()) return;
            style->setFloating(e->parentNode()->style()->floating());
            return;
        }
        if(!primitiveValue) return;
        EFloat f;
        switch(primitiveValue->getIdent())
        {
        case CSS_VAL_LEFT:
            f = FLEFT; break;
        case CSS_VAL_RIGHT:
            f = FRIGHT; break;
        case CSS_VAL_NONE:
            f = FNONE; break;
        default:
            return;
        }
        style->setFloating(f);
        break;
    }

        break;
    case CSS_PROP_FONT_STRETCH:
        break;

    case CSS_PROP_FONT_STYLE:
    {
        MGFont f = style->font();
        if(value->valueType() == CSSValue::CSS_INHERIT)
        {
            if(!e->parentNode()) return;
            f.setItalic(e->parentNode()->style()->font().italic());
            style->setFont(f);
            return;
        }
        if(!primitiveValue) return;
        switch(primitiveValue->getIdent())
        {
            // ### oblique is the same as italic for the moment...
        case CSS_VAL_OBLIQUE:
        case CSS_VAL_ITALIC:
            f.setItalic(true);
            break;
        case CSS_VAL_NORMAL:
            f.setItalic(false);
            break;
        default:
            return;
        }
        style->setFont(f);
        break;
    }


    case CSS_PROP_FONT_VARIANT:
        // ### no small caps at the moment...
        break;

    case CSS_PROP_FONT_WEIGHT:
    {
        MGFont f = style->font();
        if(value->valueType() == CSSValue::CSS_INHERIT)
        {
            if(!e->parentNode()) return;
            f.setWeight(e->parentNode()->style()->font().weight());
            style->setFont(f);
            return;
        }
        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:
                f.setWeight(MG::Bold);
                break;
            case CSS_VAL_NORMAL:
            case CSS_VAL_LIGHTER:
                f.setWeight(MG::Normal);
                break;
            default:
                return;
            }
        }
        else
        {
            // ### fix parsing of 100-900 values in parser, apply them here
        }
        style->setFont(f);
        break;
    }

    case CSS_PROP_LIST_STYLE_POSITION:
    {
        if(value->valueType() == CSSValue::CSS_INHERIT)
        {
            if(!e->parentNode()) return;
            style->setListStylePosition(e->parentNode()->style()->listStylePosition());
            return;
        }
        if(!primitiveValue) return;
        if(primitiveValue->getIdent())
        {
            EListStylePosition p;
            switch(primitiveValue->getIdent())
            {
            case CSS_VAL_INSIDE:
                p = INSIDE; break;
            case CSS_VAL_BOLDER:
                p = OUTSIDE; break;
            default:
                return;
            }
            style->setListStylePosition(p);
        }
        return;
    }

    case CSS_PROP_LIST_STYLE_TYPE:
    {
        if(value->valueType() == CSSValue::CSS_INHERIT)
        {
            if(!e->parentNode()) return;
            style->setListStyleType(e->parentNode()->style()->listStyleType());
            return;
        }
        if(!primitiveValue) return;
        if(primitiveValue->getIdent())
        {
            EListStyleType t;
            switch(primitiveValue->getIdent())
            {
            case CSS_VAL_DISC:
                t = DISC; break;
            case CSS_VAL_CIRCLE:
                t = CIRCLE; break;
            case CSS_VAL_SQUARE:
                t = SQUARE; break;
            case CSS_VAL_HEBREW:
                t = HEBREW; break;
            case CSS_VAL_ARMENIAN:
                t = ARMENIAN; break;
            case CSS_VAL_GEORGIAN:
                t = GEORGIAN; break;
            case CSS_VAL_CJK_IDEOGRAPHIC:
                t = CJK_IDEOGRAPHIC; break;
            case CSS_VAL_HIRAGANA:
                t = HIRAGANA; break;
            case CSS_VAL_KATAKANA:
                t = KATAKANA; break;
            case CSS_VAL_HIRAGANA_IROHA:
                t = HIRAGANA_IROHA; break;
            case CSS_VAL_KATAKANA_IROHA:
                t = KATAKANA_IROHA; break;
            case CSS_VAL_DECIMAL_LEADING_ZERO:
                t = DECIMAL_LEADING_ZERO; break;
            case CSS_VAL_DECIMAL:
                t = LDECIMAL; break;
            case CSS_VAL_LOWER_ROMAN:
                t = LOWER_ROMAN; break;
            case CSS_VAL_UPPER_ROMAN:
                t = UPPER_ROMAN; break;
            case CSS_VAL_LOWER_GREEK:
                t = LOWER_GREEK; break;
            case CSS_VAL_LOWER_ALPHA:
                t = LOWER_ALPHA; break;
            case CSS_VAL_LOWER_LATIN:
                t = LOWER_LATIN; break;
            case CSS_VAL_UPPER_ALPHA:
                t = UPPER_ALPHA; break;
            case CSS_VAL_UPPER_LATIN:
                t = UPPER_LATIN; break;
            case CSS_VAL_NONE:
                t = LNONE; break;
            default:
                return;
            }
            style->setListStyleType(t);
        }
        return;
    }

    case CSS_PROP_OUTLINE_STYLE:
    case CSS_PROP_OVERFLOW:
    case CSS_PROP_PAGE:
    case CSS_PROP_PAGE_BREAK_AFTER:
    case CSS_PROP_PAGE_BREAK_BEFORE:
    case CSS_PROP_PAGE_BREAK_INSIDE:
    case CSS_PROP_PAUSE_AFTER:
    case CSS_PROP_PAUSE_BEFORE:
        break;

    case CSS_PROP_POSITION:
    {
        if(value->valueType() == CSSValue::CSS_INHERIT)
        {
            if(!e->parentNode()) return;
            style->setPosition(e->parentNode()->style()->position());
            return;
        }
        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:
            {
                DocumentImpl *doc = e->ownerDocument();
                if(doc && doc->view())
                    doc->view()->useSlowRepaints();
                p = FIXED; break;
            }
        default:
            return;
        }
        style->setPosition(p);
        return;
    }

    case CSS_PROP_SPEAK:
    case CSS_PROP_SPEAK_HEADER:
    case CSS_PROP_SPEAK_NUMERAL:
    case CSS_PROP_SPEAK_PUNCTUATION:
    case CSS_PROP_TABLE_LAYOUT:
    case CSS_PROP_TEXT_TRANSFORM:
    case CSS_PROP_UNICODE_BIDI:
        break;
    case CSS_PROP_VISIBILITY:
        {
        if(value->valueType() == CSSValue::CSS_INHERIT) {
            if(!e->parentNode()) return;
            style->setVisiblity(e->parentNode()->style()->visiblity());
            return;
        }

        if(!primitiveValue->getIdent()) return;

        EVisiblity s;
        switch(primitiveValue->getIdent()) {
        case CSS_VAL_VISIBLE:
            s = VISIBLE;
            break;
        case CSS_VAL_HIDDEN:
            s = HIDDEN;
            break;
        case CSS_VAL_COLLAPSE:
            s = COLLAPSE;
            break;
        default:
            return;
        }
        style->setVisiblity(s);
        break;
        }

    case CSS_PROP_WHITE_SPACE:
        if(value->valueType() == CSSValue::CSS_INHERIT) {
            if(!e->parentNode()) return;
            style->setWhiteSpace(e->parentNode()->style()->whiteSpace());
            return;
        }

        if(!primitiveValue->getIdent()) return;

        EWhiteSpace s;
        switch(primitiveValue->getIdent()) {
        case CSS_VAL_NOWRAP:
            s = NOWRAP;
            break;
        case CSS_VAL_PRE:
            s = PRE;
            break;
        case CSS_VAL_NORMAL:
        default:
            s = NORMAL;
            break;
        }
        style->setWhiteSpace(s);
        break;


// special properties (css_extensions)
    case CSS_PROP_AZIMUTH:
        // CSS2Azimuth
    case CSS_PROP_BACKGROUND_POSITION:
        // CSS2BackgroundPosition
        break;
    case CSS_PROP_KONQ_BGPOS_X:
      {
      if(!primitiveValue) break;
      Length l;
      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;
      style->setBackgroundXPosition(l);
      break;
      }
    case CSS_PROP_KONQ_BGPOS_Y:
      {
      if(!primitiveValue) break;
      Length l;
      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;
      style->setBackgroundYPosition(l);
      break;
      }
    case CSS_PROP_BORDER_SPACING:
        {
        if(!primitiveValue) break;
        short spacing = 0;
        spacing = computeLength(primitiveValue, style, part);
        style->setBorderSpacing(spacing);
        break;
        }
        // CSS2BorderSpacing
    case CSS_PROP_CURSOR:
        // CSS2Cursor
        if(value->valueType() == CSSValue::CSS_INHERIT) {
            if(!e->parentNode()) return;
            style->setCursor(e->parentNode()->style()->cursor());
            return;
        }

        if(!primitiveValue->getIdent()) return;
        {
            ECursor c = CURSOR_AUTO;
            switch(primitiveValue->getIdent()) {
            case CSS_VAL_AUTO:
                break;
            case CSS_VAL_DEFAULT:
                c = CURSOR_DEFAULT; break;
                // ### shouldn't that be crosshair????
            case CSS_VAL_CROSSHAIR:
                c = CURSOR_CROSS; break;
            case CSS_VAL_POINTER:
                c = CURSOR_POINTER; break;
            case CSS_VAL_MOVE:
                c = CURSOR_MOVE; break;
            case CSS_VAL_E_RESIZE:
                c = CURSOR_E_RESIZE; break;
            case CSS_VAL_NE_RESIZE:
                c = CURSOR_NE_RESIZE; break;
            case CSS_VAL_NW_RESIZE:
                c = CURSOR_NW_RESIZE; break;
            case CSS_VAL_N_RESIZE:
                c = CURSOR_N_RESIZE; break;
            case CSS_VAL_SE_RESIZE:
                c = CURSOR_SE_RESIZE; break;
            case CSS_VAL_SW_RESIZE:
                c = CURSOR_SW_RESIZE; break;
            case CSS_VAL_S_RESIZE:
                c = CURSOR_S_RESIZE; break;
            case CSS_VAL_W_RESIZE:
                c = CURSOR_W_RESIZE; break;
            case CSS_VAL_TEXT:
                c = CURSOR_TEXT; break;
            case CSS_VAL_WAIT:
                c = CURSOR_WAIT; break;
            case CSS_VAL_HELP:
                c = CURSOR_HELP; break;
            }
            style->setCursor(c);
        }
        break;
    case CSS_PROP_PLAY_DURING:
        // CSS2PlayDuring
    case CSS_PROP_TEXT_SHADOW:
        // list of CSS2TextShadow
        break;