cssparser.cpp

khtml在gtk上的移植版本

	    valid_primitive = true;
	break;

    case CSS_PROP_BACKGROUND_IMAGE:     // <uri> | none | inherit
    case CSS_PROP_LIST_STYLE_IMAGE:     // <uri> | none | inherit

	if ( id == CSS_VAL_NONE ) {
	    parsedValue = new CSSImageValueImpl();
	    valueList->next();
#ifdef CSS_DEBUG
	    kdDebug( 6080 ) << "empty image " << endl;
#endif
	} else if ( value->unit == CSSPrimitiveValue::CSS_URI ) {
	    // ### allow string in non strict mode?
	    DOMString uri = khtml::parseURL( domString( value->string ) );
	    if ( !uri.isEmpty() ) {
		parsedValue = new CSSImageValueImpl(
		    DOMString(KURL( styleElement->baseURL().string(), uri.string()).url()),
		    styleElement );
		valueList->next();
#ifdef CSS_DEBUG
		kdDebug( 6080 ) << "image, url=" << uri.string() << " base=" << styleElement->baseURL().string() << endl;
#endif
	    }
	}
	break;

    case CSS_PROP_OUTLINE_WIDTH:        // <border-width> | inherit
    case CSS_PROP_BORDER_TOP_WIDTH:     //// <border-width> | inherit
    case CSS_PROP_BORDER_RIGHT_WIDTH:   //   Which is defined as
    case CSS_PROP_BORDER_BOTTOM_WIDTH:  //   thin | medium | thick | <length>
    case CSS_PROP_BORDER_LEFT_WIDTH:    ////
	if (id == CSS_VAL_THIN || id == CSS_VAL_MEDIUM || id == CSS_VAL_THICK)
	    valid_primitive = true;
        else
            valid_primitive = ( validUnit( value, FLength, strict ) );
	break;

    case CSS_PROP_LETTER_SPACING:       // normal | <length> | inherit
    case CSS_PROP_WORD_SPACING:         // normal | <length> | inherit
	if ( id == CSS_VAL_NORMAL )
	    valid_primitive = true;
	else
            valid_primitive = validUnit( value, FLength, strict );
	break;

    case CSS_PROP_TEXT_INDENT:          // <length> | <percentage> | inherit
    case CSS_PROP_PADDING_TOP:          //// <padding-width> | inherit
    case CSS_PROP_PADDING_RIGHT:        //   Which is defined as
    case CSS_PROP_PADDING_BOTTOM:       //   <length> | <percentage>
    case CSS_PROP_PADDING_LEFT:         ////
	valid_primitive = ( !id && validUnit( value, FLength|FPercent, strict ) );
	break;

    case CSS_PROP_MAX_HEIGHT:           // <length> | <percentage> | none | inherit
    case CSS_PROP_MAX_WIDTH:            // <length> | <percentage> | none | inherit
	if (id == CSS_VAL_NONE || id == CSS_VAL_INTRINSIC || id == CSS_VAL_MIN_INTRINSIC) {
	    valid_primitive = true;
	    break;
	}
	/* nobreak */
    case CSS_PROP_MIN_HEIGHT:           // <length> | <percentage> | inherit
    case CSS_PROP_MIN_WIDTH:            // <length> | <percentage> | inherit
        if (id == CSS_VAL_INTRINSIC || id == CSS_VAL_MIN_INTRINSIC)
            valid_primitive = true;
        else
            valid_primitive = ( !id && validUnit( value, FLength|FPercent|FNonNeg, strict ) );
	break;

    case CSS_PROP_FONT_SIZE:
    	// <absolute-size> | <relative-size> | <length> | <percentage> | inherit
	if (id >= CSS_VAL_XX_SMALL && id <= CSS_VAL_LARGER)
	    valid_primitive = true;
	else
	    valid_primitive = ( validUnit( value, FLength|FPercent, strict ) );
	break;

    case CSS_PROP_FONT_STYLE:           // normal | italic | oblique | inherit
	if ( id == CSS_VAL_NORMAL || id == CSS_VAL_ITALIC || id == CSS_VAL_OBLIQUE)
	    valid_primitive = true;
	break;

    case CSS_PROP_FONT_VARIANT:         // normal | small-caps | inherit
	if ( id == CSS_VAL_NORMAL || id == CSS_VAL_SMALL_CAPS)
	    valid_primitive = true;
	break;

    case CSS_PROP_VERTICAL_ALIGN:
    	// baseline | sub | super | top | text-top | middle | bottom | text-bottom |
	// <percentage> | <length> | inherit

	if ( id >= CSS_VAL_BASELINE && id <= CSS_VAL__KHTML_BASELINE_MIDDLE )
	    valid_primitive = true;
	else
	    valid_primitive = ( !id && validUnit( value, FLength|FPercent, strict ) );
	break;

    case CSS_PROP_HEIGHT:               // <length> | <percentage> | auto | inherit
    case CSS_PROP_WIDTH:                // <length> | <percentage> | auto | inherit
	if (id == CSS_VAL_AUTO || id == CSS_VAL_INTRINSIC || id == CSS_VAL_MIN_INTRINSIC)
	    valid_primitive = true;
	else
	    // ### handle multilength case where we allow relative units
	    valid_primitive = ( !id && validUnit( value, FLength|FPercent|FNonNeg, strict ) );
	break;

    case CSS_PROP_BOTTOM:               // <length> | <percentage> | auto | inherit
    case CSS_PROP_LEFT:                 // <length> | <percentage> | auto | inherit
    case CSS_PROP_RIGHT:                // <length> | <percentage> | auto | inherit
    case CSS_PROP_TOP:                  // <length> | <percentage> | auto | inherit
    case CSS_PROP_MARGIN_TOP:           //// <margin-width> | inherit
    case CSS_PROP_MARGIN_RIGHT:         //   Which is defined as
    case CSS_PROP_MARGIN_BOTTOM:        //   <length> | <percentage> | auto | inherit
    case CSS_PROP_MARGIN_LEFT:          ////
	if ( id == CSS_VAL_AUTO )
	    valid_primitive = true;
	else
	    valid_primitive = ( !id && validUnit( value, FLength|FPercent, strict ) );
	break;

    case CSS_PROP_Z_INDEX:              // auto | <integer> | inherit
	// qDebug("parsing z-index: id=%d, fValue=%f", id, value->fValue );
	if ( id == CSS_VAL_AUTO ) {
            valid_primitive = true;
            break;
	}
	/* nobreak */
    case CSS_PROP_ORPHANS:              // <integer> | inherit
    case CSS_PROP_WIDOWS:               // <integer> | inherit
	// ### not supported later on
	valid_primitive = ( !id && validUnit( value, FInteger, false ) );
	break;

    case CSS_PROP_LINE_HEIGHT:          // normal | <number> | <length> | <percentage> | inherit
	if ( id == CSS_VAL_NORMAL )
	    valid_primitive = true;
	else
	    valid_primitive = ( !id && validUnit( value, FNumber|FLength|FPercent, strict ) );
	break;
#if 0
	// removed from CSS 2.1
    case CSS_PROP_COUNTER_INCREMENT:    // [ <identifier> <integer>? ]+ | none | inherit
    case CSS_PROP_COUNTER_RESET:        // [ <identifier> <integer>? ]+ | none | inherit
	if ( id == CSS_VAL_NONE )
	    valid_primitive = true;
	else {
            CSSValueListImpl *list = new CSSValueListImpl;
            int pos=0, pos2;
            while( 1 )
	    {
                pos2 = value.find(',', pos);
                QString face = value.mid(pos, pos2-pos);
                face = face.stripWhiteSpace();
                if(face.length() == 0) break;
                // ### single quoted is missing...
                if(face[0] == '\"') face.remove(0, 1);
                if(face[face.length()-1] == '\"') face = face.left(face.length()-1);
                //kdDebug( 6080 ) << "found face '" << face << "'" << endl;
                list->append(new CSSPrimitiveValueImpl(DOMString(face), CSSPrimitiveValue::CSS_STRING));
                pos = pos2 + 1;
                if(pos2 == -1) break;
	    }
            //kdDebug( 6080 ) << "got " << list->length() << " faces" << endl;
            if(list->length()) {
		parsedValue = list;
		valueList->next();
            } else
		delete list;
            break;
	}
#endif
    case CSS_PROP_FONT_FAMILY:
    	// [[ <family-name> | <generic-family> ],]* [<family-name> | <generic-family>] | inherit
    {
	parsedValue = parseFontFamily();
	break;
    }

    case CSS_PROP_TEXT_DECORATION:
    	// none | [ underline || overline || line-through || blink ] | inherit
	if (id == CSS_VAL_NONE) {
	    valid_primitive = true;
	} else {
	    CSSValueListImpl *list = new CSSValueListImpl;
	    bool is_valid = true;
	    while( is_valid && value ) {
		switch ( value->id ) {
		case CSS_VAL_BLINK:
		    break;
		case CSS_VAL_UNDERLINE:
		case CSS_VAL_OVERLINE:
		case CSS_VAL_LINE_THROUGH:
		    list->append( new CSSPrimitiveValueImpl( value->id ) );
		    break;
		default:
		    is_valid = false;
		}
		value = valueList->next();
	    }
	    //kdDebug( 6080 ) << "got " << list->length() << "d decorations" << endl;
	    if(list->length() && is_valid) {
                parsedValue = list;
		valueList->next();
	    } else {
                delete list;
	    }
	}
	break;

    case CSS_PROP_TABLE_LAYOUT:         // auto | fixed | inherit
	if ( id == CSS_VAL_AUTO || id == CSS_VAL_FIXED )
	    valid_primitive = true;
	break;

    /* CSS3 properties */
    case CSS_PROP__KHTML_BINDING:
#ifndef KHTML_NO_XBL
        if (id == CSS_VAL_NONE)
            valid_primitive = true;
        else {
            CSSValueListImpl* values = new CSSValueListImpl();
            Value* val;
            CSSValueImpl* parsedValue = 0;
            while ((val = valueList->current())) {
                if (val->unit == CSSPrimitiveValue::CSS_URI) {
                    DOMString value = khtml::parseURL(domString(val->string));
                    parsedValue = new CSSPrimitiveValueImpl(
                                    DOMString(KURL(styleElement->baseURL().string(), value.string()).url()), 
                                    CSSPrimitiveValue::CSS_URI);
                } 
                
                if (parsedValue)
                    values->append(parsedValue);
                else
                    break;
                valueList->next();
            }
            if ( values->length() ) {
                addProperty( propId, values, important );
                valueList->next();
                return true;
            }
            delete values;
            return false;
        }
#endif
        break;
    case CSS_PROP_OUTLINE_OFFSET:
        valid_primitive = validUnit(value, FLength, strict);
        break;
    case CSS_PROP_TEXT_SHADOW: // CSS2 property, dropped in CSS2.1, back in CSS3, so treat as CSS3
        if (id == CSS_VAL_NONE)
            valid_primitive = true;
        else
            return parseShadow(propId, important);
        break;
    case CSS_PROP_OPACITY:
        valid_primitive = validUnit(value, FNumber, strict);
        break;
    case CSS_PROP__KHTML_BOX_ALIGN:
        if (id == CSS_VAL_STRETCH || id == CSS_VAL_START || id == CSS_VAL_END ||
            id == CSS_VAL_CENTER || id == CSS_VAL_BASELINE)
            valid_primitive = true;
        break;
    case CSS_PROP__KHTML_BOX_DIRECTION:
        if (id == CSS_VAL_NORMAL || id == CSS_VAL_REVERSE)
            valid_primitive = true;
        break;
    case CSS_PROP__KHTML_BOX_LINES:
        if (id == CSS_VAL_SINGLE || id == CSS_VAL_MULTIPLE)
            valid_primitive = true;
        break;
    case CSS_PROP__KHTML_BOX_ORIENT:
        if (id == CSS_VAL_HORIZONTAL || id == CSS_VAL_VERTICAL ||
            id == CSS_VAL_INLINE_AXIS || id == CSS_VAL_BLOCK_AXIS)
            valid_primitive = true;
        break;
    case CSS_PROP__KHTML_BOX_PACK:
        if (id == CSS_VAL_START || id == CSS_VAL_END ||
            id == CSS_VAL_CENTER || id == CSS_VAL_JUSTIFY)
            valid_primitive = true;
        break;
    case CSS_PROP__KHTML_BOX_FLEX:
        valid_primitive = validUnit(value, FNumber, strict);
        break;
    case CSS_PROP__KHTML_BOX_FLEX_GROUP:
    case CSS_PROP__KHTML_BOX_ORDINAL_GROUP:
        valid_primitive = validUnit(value, FInteger|FNonNeg, true);
        break;
    case CSS_PROP__KHTML_MARQUEE: {
        const int properties[5] = { CSS_PROP__KHTML_MARQUEE_DIRECTION, CSS_PROP__KHTML_MARQUEE_INCREMENT,
                                    CSS_PROP__KHTML_MARQUEE_REPETITION,
                                    CSS_PROP__KHTML_MARQUEE_STYLE, CSS_PROP__KHTML_MARQUEE_SPEED };
        return parseShortHand(properties, 5, important);
    }
    case CSS_PROP__KHTML_MARQUEE_DIRECTION:
        if (id == CSS_VAL_FORWARDS || id == CSS_VAL_BACKWARDS || id == CSS_VAL_AHEAD ||
            id == CSS_VAL_REVERSE || id == CSS_VAL_LEFT || id == CSS_VAL_RIGHT || id == CSS_VAL_DOWN ||
            id == CSS_VAL_UP || id == CSS_VAL_AUTO)
            valid_primitive = true;
        break;
    case CSS_PROP__KHTML_MARQUEE_INCREMENT:
        if (id == CSS_VAL_SMALL || id == CSS_VAL_LARGE || id == CSS_VAL_MEDIUM)
            valid_primitive = true;
        else
            valid_primitive = validUnit(value, FLength|FPercent, strict);
        break;
    case CSS_PROP__KHTML_MARQUEE_STYLE:
        if (id == CSS_VAL_NONE || id == CSS_VAL_SLIDE || id == CSS_VAL_SCROLL || id == CSS_VAL_ALTERNATE ||
            id == CSS_VAL_UNFURL)
            valid_primitive = true;
        break;
    case CSS_PROP__KHTML_MARQUEE_REPETITION:
        if (id == CSS_VAL_INFINITE)
            valid_primitive = true;
        else
            valid_primitive = validUnit(value, FInteger|FNonNeg, strict);
        break;
    case CSS_PROP__KHTML_MARQUEE_SPEED:
        if (id == CSS_VAL_NORMAL || id == CSS_VAL_SLOW || id == CSS_VAL_FAST)
            valid_primitive = true;
        else
            valid_primitive = validUnit(value, FTime|FInteger|FNonNeg, strict);
        break;
    case CSS_PROP__KHTML_USER_DRAG: // auto | none | element
        if (id == CSS_VAL_AUTO || id == CSS_VAL_NONE || id == CSS_VAL_ELEMENT)
            valid_primitive = true;
        break;
    case CSS_PROP__KHTML_USER_MODIFY:	// read-only | read-write
        if (id == CSS_VAL_READ_ONLY || id == CSS_VAL_READ_WRITE)
            valid_primitive = true;
        break;
    case CSS_PROP__KHTML_USER_SELECT: // auto | none | text
        if (id == CSS_VAL_AUTO || id == CSS_VAL_NONE || id == CSS_VAL_TEXT)
            valid_primitive = true;
        break;
    case CSS_PROP_TEXT_OVERFLOW: // clip | ellipsis
        if (id == CSS_VAL_CLIP || id == CSS_VAL_ELLIPSIS)
            valid_primitive = true;
        break;
    // End of CSS3 properties

#if APPLE_CHANGES
    // Apple specific properties.  These will never be standardized and are purely to
    // support custom WebKit-based Apple applications.
    case CSS_PROP__APPLE_LINE_CLAMP:
        valid_primitive = (!id && validUnit(value, FPercent, false));
        break;
    case CSS_PROP__APPLE_TEXT_SIZE_ADJUST:
        if (id == CSS_VAL_AUTO || id == CSS_VAL_NONE)
            valid_primitive = true;
        break;
#endif

	/* shorthand properties */
    case CSS_PROP_BACKGROUND:
    	// ['background-color' || 'background-image' ||'background-repeat' ||
	// 'background-attachment' || 'background-position'] | inherit
    {
#ifdef CSS_DEBUG_BCKGR
	kdDebug(6080) << "CSS_PROP_BACKGROUND" << endl;
#endif
	const int properties[5] = { CSS_PROP_BACKGROUND_IMAGE, CSS_PROP_BACKGROUND_REPEAT,
				    CSS_PROP_BACKGROUND_ATTACHMENT, CSS_PROP_BACKGROUND_POSITION,
				    CSS_PROP_BACKGROUND_COLOR };
	return parseShortHand(properties, 5, important);
    }
    case CSS_PROP_BORDER:
 	// [ 'border-width' || 'border-style' || <color> ] | inherit
    {
	const int properties[3] = { CSS_PROP_BORDER_WIDTH, CSS_PROP_BORDER_STYLE,
				    CSS_PROP_BORDER_COLOR };
	return parseShortHand(properties, 3, important);
    }
    case CSS_PROP_BORDER_TOP:
    	// [ 'border-top-width' || 'border-style' || <color> ] | inherit
    {
	const int properties[3] = { CSS_PROP_BORDER_TOP_WIDTH, CSS_PROP_BORDER_TOP_STYLE,
				    CSS_PROP_BORDER_TOP_COLOR};
	return parseShortHand(properties, 3, important);
    }
    case CSS_PROP_BORDER_RIGHT:
    	// [ 'border-right-width' || 'border-style' || <color> ] | inherit
    {
	const int properties[3] = { CSS_PROP_BORDER_RIGHT_WIDTH, CSS_PROP_BORDER_RIGHT_STYLE,