cssparser.cpp

来自「将konqueror浏览器移植到ARM9 2410中」· C++ 代码 · 共 2,040 行 · 第 1/5 页

      /* Start of supported CSS properties with validation. This is needed for parseShortHand to work
       * correctly and allows optimization in khtml::applyRule(..)
       */
      case CSS_PROP_CAPTION_SIDE:         // top | bottom | left | right | inherit
	{
	  if (cssval) {
	    int id = cssval->id;
	    if (id == CSS_VAL_LEFT || id == CSS_VAL_RIGHT || id == CSS_VAL_TOP || id == CSS_VAL_BOTTOM) {
	      parsedValue = new CSSPrimitiveValueImpl(id);
	    }
	  }
	  break;
	}
      case CSS_PROP_BORDER_COLLAPSE:      // collapse | separate | inherit
	{
	  if (cssval) {
	    int id = cssval->id;
	    if ( id == CSS_VAL_COLLAPSE || id == CSS_VAL_SEPARATE ) {
	      parsedValue = new CSSPrimitiveValueImpl(id);
	    }
	  }
	  break;
	}
      case CSS_PROP_VISIBILITY:           // visible | hidden | collapse | inherit
	{
	  if (cssval) {
	    int id = cssval->id;
	    if (id == CSS_VAL_VISIBLE || id == CSS_VAL_HIDDEN || id == CSS_VAL_COLLAPSE) {
	      parsedValue = new CSSPrimitiveValueImpl(id);
	    }
	  }
	  break;
	}
      case CSS_PROP_OVERFLOW:             // visible | hidden | scroll | auto | inherit
	{
	  if (cssval) {
	    int id = cssval->id;
	    if ( id == CSS_VAL_VISIBLE || id == CSS_VAL_HIDDEN || id == CSS_VAL_SCROLL || id == CSS_VAL_AUTO ) {
	      parsedValue = new CSSPrimitiveValueImpl(id);
	    }
	  }
	  break;
	}
      case CSS_PROP_LIST_STYLE_POSITION:  // inside | outside | inherit
	{
	  if (cssval) {
	    int id = cssval->id;
	    if ( id == CSS_VAL_INSIDE || id == CSS_VAL_OUTSIDE ) {
	      parsedValue = new CSSPrimitiveValueImpl(id);
	    }
	  }
	  break;
	}
      case CSS_PROP_LIST_STYLE_TYPE:
        // disc | circle | square | decimal | decimal-leading-zero | lower-roman |
        // upper-roman | lower-greek | lower-alpha | lower-latin | upper-alpha |
        // upper-latin | hebrew | armenian | georgian | cjk-ideographic | hiragana |
        // katakana | hiragana-iroha | katakana-iroha | none | inherit
	{
	  if (cssval) {
            int id = cssval->id;
            if ((id >= CSS_VAL_DISC && id <= CSS_VAL_KATAKANA_IROHA) || id == CSS_VAL_NONE) {
	      parsedValue = new CSSPrimitiveValueImpl(id);
            }
	  }
	  break;
	}
      case CSS_PROP_DISPLAY:
        // inline | block | list-item | run-in | compact | -konq-ruler | marker | table |
        // inline-table | table-row-group | table-header-group | table-footer-group | table-row |
        // table-column-group | table-column | table-cell | table-caption | none | inherit
	{
	  if (cssval) {
            int id = cssval->id;
            if ((id >= CSS_VAL_INLINE && id <= CSS_VAL_TABLE_CAPTION) || id == CSS_VAL_NONE) {
	      parsedValue = new CSSPrimitiveValueImpl(id);
            }
	  }
	  break;
	}
      case CSS_PROP_DIRECTION:            // ltr | rtl | inherit
	{
	  if (cssval) {
	    int id = cssval->id;
	    if ( id == CSS_VAL_LTR || id == CSS_VAL_RTL ) {
	      parsedValue = new CSSPrimitiveValueImpl(id);
	    }
	  }
	  break;
	}
      case CSS_PROP_TEXT_TRANSFORM:       // capitalize | uppercase | lowercase | none | inherit
	{
	  if (cssval) {
	    int id = cssval->id;
	    if ((id >= CSS_VAL_CAPITALIZE && id <= CSS_VAL_LOWERCASE) || id == CSS_VAL_NONE) {
	      parsedValue = new CSSPrimitiveValueImpl(id);
	    }
	  }
	  break;
	}
      case CSS_PROP_FLOAT:                // left | right | none | inherit + center for buggy CSS
	{
	  if (cssval) {
            int id = cssval->id;
            if (id == CSS_VAL_LEFT || id == CSS_VAL_RIGHT
		|| id == CSS_VAL_NONE || id == CSS_VAL_CENTER) {
	      parsedValue = new CSSPrimitiveValueImpl(id);
	    }
	  }
	  break;
	}
      case CSS_PROP_CLEAR:                // none | left | right | both | inherit
	{
	  if (cssval) {
            int id = cssval->id;
            if (id == CSS_VAL_NONE || id == CSS_VAL_LEFT
		|| id == CSS_VAL_RIGHT|| id == CSS_VAL_BOTH) {
	      parsedValue = new CSSPrimitiveValueImpl(id);
	    }
	  }
	  break;
	}
      case CSS_PROP_TEXT_ALIGN:
    	// left | right | center | justify | konq_center | <string> | inherit
	{
	  if (cssval) {
            int id = cssval->id;
            if (id >= CSS_VAL_LEFT && id <= CSS_VAL__KONQ_CENTER) {
	      parsedValue = new CSSPrimitiveValueImpl(id);
	      break;
            }
	  } else {
            parsedValue = new CSSPrimitiveValueImpl(DOMString(curP, endP - curP),
			                            CSSPrimitiveValue::CSS_STRING);
	  }
	  break;
	}
      case CSS_PROP_OUTLINE_STYLE:        // <border-style> | inherit
      case CSS_PROP_BORDER_TOP_STYLE:     //// <border-style> | inherit
      case CSS_PROP_BORDER_RIGHT_STYLE:   //   Defined as:    none | hidden | dotted | dashed |
      case CSS_PROP_BORDER_BOTTOM_STYLE:  //   solid | double | groove | ridge | inset | outset
      case CSS_PROP_BORDER_LEFT_STYLE:    ////
	{
	  if (cssval) {
            int id = cssval->id;
            if (id >= CSS_VAL_NONE && id <= CSS_VAL_OUTSET) {
	      parsedValue = new CSSPrimitiveValueImpl(id);
            }
	  }
	  break;
	}
      case CSS_PROP_FONT_WEIGHT:  // normal | bold | bolder | lighter | 100 | 200 | 300 | 400 |
	// 500 | 600 | 700 | 800 | 900 | inherit
	{
	  if (cssval) {
            int id = cssval->id;
            if (id) {
	      if (id >= CSS_VAL_NORMAL && id <= CSS_VAL_LIGHTER) {
		// Allready correct id
	      } else if (id >= CSS_VAL_100 && id <= CSS_VAL_500) {
		id = CSS_VAL_NORMAL;
	      } else if (id >= CSS_VAL_600 && id <= CSS_VAL_900) {
		id = CSS_VAL_BOLD;
	      }
	      parsedValue = new CSSPrimitiveValueImpl(id);
	    }
	  }
	  break;
	}
      case CSS_PROP_BACKGROUND_REPEAT:    // repeat | repeat-x | repeat-y | no-repeat | inherit
	{
#ifdef CSS_DEBUG_BCKGR
	  kdDebug( 6080 ) << "CSS_PROP_BACKGROUND_REPEAT: " << val << endl;
#endif
	  if (cssval) {
            int id = cssval->id;
            if ( id >= CSS_VAL_REPEAT && id <= CSS_VAL_NO_REPEAT ) {
	      parsedValue = new CSSPrimitiveValueImpl(id);
            }
	  }
	  break;
	}
      case CSS_PROP_BACKGROUND_ATTACHMENT: // scroll | fixed
	{
#ifdef CSS_DEBUG_BCKGR
	  kdDebug( 6080 ) << "CSS_PROP_BACKGROUND_ATTACHEMENT: " << val << endl;
#endif
	  if (cssval) {
            int id = cssval->id;
            if ( id == CSS_VAL_SCROLL || id == CSS_VAL_FIXED ) {
	      parsedValue = new CSSPrimitiveValueImpl(id);
            }
	  }
	  break;
	}
      case CSS_PROP_BACKGROUND_POSITION:
	{
#ifdef CSS_DEBUG_BCKGR
	  kdDebug( 6080 ) << "CSS_PROP_BACKGROUND_POSITION: " << val << endl;
#endif
	  /* Problem: center is ambigous
	   * In case of 'center' center defines X and Y coords
	   * In case of 'center top', center defines the Y coord
	   * in case of 'center left', center defines the X coord
	   */
	  bool isLast;
	  const QChar* nextP = getNext(curP, endP, isLast);
	  QConstString property1(const_cast<QChar*>( curP ), nextP - curP);
	  const struct css_value *cssval1 = findValue( property1.string().ascii(),
						       property1.string().length());
	  if ( !cssval1 ) {
            int properties[2] = { CSS_PROP_BACKGROUND_POSITION_X,
				  CSS_PROP_BACKGROUND_POSITION_Y };
            return parseShortHand(curP, endP, properties, 2);
	  }
	  const struct css_value *cssval2 = 0;
#ifdef CSS_DEBUG
	  kdDebug( 6080 ) << "prop 1: [" << property1.string() << "]" << " isLast: " << isLast <<  endl;
#endif
	  if ( !isLast) {
            curP = nextP+1;
            nextP = getNext(curP, endP, isLast);
            QConstString property2(const_cast<QChar*>( curP ), nextP - curP);
            cssval2 = findValue( property2.string().ascii(), property2.string().length());
#ifdef CSS_DEBUG
            kdDebug( 6080 ) << "prop 2: [" << property2.string() << "]" << " isLast: " << isLast <<  endl;
#endif
	  }

	  int valX = -1;
	  int valY = -1;
	  int id1 = cssval1 ? cssval1->id : -1;
	  int id2 = cssval2 ? cssval2->id : CSS_VAL_CENTER;
	  // id1 will influence X and id2 will influence Y
	  if ( id2 == CSS_VAL_LEFT || id2 == CSS_VAL_RIGHT ||
	       id1 == CSS_VAL_TOP  || id1 == CSS_VAL_BOTTOM) {
            int h = id1; id1 = id2; id2 = h;
	  }

	  switch( id1 ) {
	  case CSS_VAL_LEFT:   valX = 0;   break;
	  case CSS_VAL_CENTER: valX = 50;  break;
	  case CSS_VAL_RIGHT:  valX = 100; break;
	  default: break;
	  }

	  switch ( id2 ) {
	  case CSS_VAL_TOP:    valY = 0;   break;
	  case CSS_VAL_CENTER: valY = 50;  break;
	  case CSS_VAL_BOTTOM: valY = 100; break;
	  default: break;
	  }

#ifdef CSS_DEBUG
	  kdDebug( 6080 ) << "valX: " << valX << " valY: " << valY <<  endl;
#endif
	  /* CSS 14.2
	   * Keywords cannot be combined with percentage values or length values.
	   * -> No mix between keywords and other units.
	   */
	  if (valX !=-1 && valY !=-1) {
	    setParsedValue( CSS_PROP_BACKGROUND_POSITION_X,
			    new CSSPrimitiveValueImpl(valX, CSSPrimitiveValue::CSS_PERCENTAGE));
	    setParsedValue( CSS_PROP_BACKGROUND_POSITION_Y,
			    new CSSPrimitiveValueImpl(valY, CSSPrimitiveValue::CSS_PERCENTAGE));
	    return true;
	  }
	  break;
	}
      case CSS_PROP_BACKGROUND_POSITION_X:
      case CSS_PROP_BACKGROUND_POSITION_Y:
	{
#ifdef CSS_DEBUG
	  kdDebug( 6080 ) << "CSS_PROP_BACKGROUND_POSITION_{X|Y}: " << val << endl;
#endif
	  parsedValue = parseUnit(curP, endP, PERCENT | NUMBER | LENGTH);
	  break;
	}
      case CSS_PROP_BORDER_SPACING:
	{
	  // ### should be able to have two values
	  parsedValue = parseUnit(curP, endP, LENGTH | NONNEGATIVE);
	  break;
	}
      case CSS_PROP_OUTLINE_COLOR:        // <color> | invert | inherit
	{
#ifdef CSS_DEBUG
	  kdDebug( 6080 ) << "CSS_PROP_OUTLINE_COLOR: " << val << endl;
#endif
	  // outline has "invert" as additional keyword. we handle
	  // it as invalid color and add a special case during rendering
	  if (cssval && cssval->id == CSS_VAL_INVERT) {
            parsedValue = new CSSPrimitiveValueImpl( QColor() );
            break;
	  }
	  // Break is explictly missing, looking for <color>
	}
      case CSS_PROP_BACKGROUND_COLOR:     // <color> | transparent | inherit
	{
#ifdef CSS_DEBUG_BCKGR
	  kdDebug( 6080 ) << "CSS_PROP_BACKGROUND_COLOR: " << val << endl;
#endif
	  if (cssval && cssval->id == CSS_VAL_TRANSPARENT) {
            parsedValue = new CSSPrimitiveValueImpl( QColor() );
            break;
	  }
	  // Break is explictly missing, looking for <color>
	}
      case CSS_PROP_COLOR:                // <color> | inherit
      case CSS_PROP_BORDER_TOP_COLOR:     // <color> | inherit
      case CSS_PROP_BORDER_RIGHT_COLOR:   // <color> | inherit
      case CSS_PROP_BORDER_BOTTOM_COLOR:  // <color> | inherit
      case CSS_PROP_BORDER_LEFT_COLOR:    // <color> | inherit
      case CSS_PROP_TEXT_DECORATION_COLOR:        //
      case CSS_PROP_SCROLLBAR_FACE_COLOR:         // IE5.5
      case CSS_PROP_SCROLLBAR_SHADOW_COLOR:       // IE5.5
      case CSS_PROP_SCROLLBAR_HIGHLIGHT_COLOR:    // IE5.5
      case CSS_PROP_SCROLLBAR_3DLIGHT_COLOR:      // IE5.5
      case CSS_PROP_SCROLLBAR_DARKSHADOW_COLOR:   // IE5.5
      case CSS_PROP_SCROLLBAR_TRACK_COLOR:        // IE5.5
      case CSS_PROP_SCROLLBAR_ARROW_COLOR:        // IE5.5
	{
	  const QString val2( value.stripWhiteSpace() );
	  //kdDebug(6080) << "parsing color " << val2 << endl;
	  QColor c;
	  khtml::setNamedColor(c, val2);
	  if(!c.isValid() && (val2 != "transparent" ) && !val2.isEmpty() ) return false;
	  //kdDebug( 6080 ) << "color is: " << c.red() << ", " << c.green() << ", " << c.blue() << endl;
	  parsedValue = new CSSPrimitiveValueImpl(c);
	  break;
	}
      case CSS_PROP_BACKGROUND_IMAGE:     // <uri> | none | inherit
#ifdef CSS_DEBUG_BCKGR
	{
	  kdDebug( 6080 ) << "CSS_PROP_BACKGROUND_IMAGE: " << val << endl;
	}
#endif
      case CSS_PROP_CURSOR:
    	// [ [<uri> ,]* [ auto | crosshair | default | pointer | move | e-resize | ne-resize |
	// nw-resize | // n-resize | se-resize | sw-resize | s-resize | w-resize | text |
	// wait | help ] ] | inherit
	{
	  if (cssval) {
            int id = cssval->id;
            if (id >= CSS_VAL_AUTO && id <= CSS_VAL_HELP) {
	      parsedValue = new CSSPrimitiveValueImpl(id);
	      break;
	    }
	  } else {
	    // Break is explictly missing, looking for <uri>
	    // ### Only supports parsing the first uri
	  }
	}
      case CSS_PROP_LIST_STYLE_IMAGE:     // <uri> | none | inherit
	{
	  if (cssval && cssval->id == CSS_VAL_NONE)
	    {
	      parsedValue = new CSSImageValueImpl();
#ifdef CSS_DEBUG
	      kdDebug( 6080 ) << "empty image " << endl;
#endif
	    } else {
	      const QString str(value.stripWhiteSpace()); // ### Optimize
	      if (str.left(4).lower() == "url(") {
		DOMString value(curP, endP - curP);
		value = khtml::parseURL(value);
            	parsedValue = new CSSImageValueImpl(value, baseUrl(), this);
#ifdef CSS_DEBUG
		kdDebug( 6080 ) << "image, url=" << value.string() << " base=" << 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 (cssval) {
            int id = cssval->id;
            if (id == CSS_VAL_THIN || id == CSS_VAL_MEDIUM || id == CSS_VAL_THICK) {
	      parsedValue = new CSSPrimitiveValueImpl(id);
            }
	  } else {
            parsedValue = parseUnit(curP, endP, LENGTH|NONNEGATIVE);
	  }
	  break;
	}
      case CSS_PROP_MARKER_OFFSET:        // <length> | auto | inherit
	{
	  if (cssval && cssval->id == CSS_VAL_AUTO) {
            parsedValue = new CSSPrimitiveValueImpl(cssval->id);
	  } else {
            parsedValue = parseUnit(curP, endP, LENGTH);
	  }
	  break;
	}
      case CSS_PROP_LETTER_SPACING:       // normal | <length> | inherit
      case CSS_PROP_WORD_SPACING:         // normal | <length> | inherit
	{
	  if (cssval) {
            if (cssval->id == CSS_VAL_NORMAL) {
	      parsedValue = new CSSPrimitiveValueImpl(cssval->id);
            }
	  } else {
            parsedValue = parseUnit(curP, endP, LENGTH);