void RenderStyle::setCounterIncrement(CSSValueListImpl *l)
{
CSSValueListImpl *t = generated->counter_increment;
generated.access()->counter_increment = l;
if (l) l->ref();
if (t) t->deref();
}
MediaQueryExp::MediaQueryExp(const DOMString &mediaFeature, ValueList *valueList)
: m_mediaFeature(mediaFeature)
, m_value(0)
{
m_viewportDependent = (m_mediaFeature == "width" ||
m_mediaFeature == "height" ||
m_mediaFeature == "min-width" ||
m_mediaFeature == "min-height" ||
m_mediaFeature == "max-width" ||
m_mediaFeature == "max-height" ||
m_mediaFeature == "orientation" ||
m_mediaFeature == "aspect-ratio" ||
m_mediaFeature == "min-aspect-ratio" ||
m_mediaFeature == "max-aspect-ratio");
if (valueList) {
if (valueList->size() == 1) {
Value *value = valueList->current();
if (value->id != 0) {
m_value = new CSSPrimitiveValueImpl(value->id);
} else if (value->unit == CSSPrimitiveValue::CSS_STRING) {
m_value = new CSSPrimitiveValueImpl(domString(value->string), (CSSPrimitiveValue::UnitTypes) value->unit);
} else if ((value->unit >= CSSPrimitiveValue::CSS_NUMBER &&
value->unit <= CSSPrimitiveValue::CSS_KHZ) ||
value->unit == CSSPrimitiveValue::CSS_DPI || value->unit == CSSPrimitiveValue::CSS_DPCM) {
m_value = new CSSPrimitiveValueImpl(value->fValue, (CSSPrimitiveValue::UnitTypes) value->unit);
}
if (m_value) {
m_value->ref();
}
valueList->next();
} else if (valueList->size() > 1) {
// create list of values
// currently accepts only <integer>/<integer>
CSSValueListImpl *list = new CSSValueListImpl();
Value *value = 0;
bool isValid = true;
while ((value = valueList->current()) && isValid) {
if (value->unit == Value::Operator && value->iValue == '/') {
list->append(new CSSPrimitiveValueImpl(DOMString("/"), CSSPrimitiveValue::CSS_STRING));
} else if (value->unit == CSSPrimitiveValue::CSS_NUMBER) {
list->append(new CSSPrimitiveValueImpl(value->fValue, CSSPrimitiveValue::CSS_NUMBER));
} else {
isValid = false;
}
value = valueList->next();
}
if (isValid) {
m_value = list;
m_value->ref();
} else {
delete list;
}
}
}
}
static CSSValueImpl* valueForShadow(const ShadowData *shadow)
{
if (!shadow)
return new CSSPrimitiveValueImpl(CSS_VAL_NONE);
CSSValueListImpl *list = new CSSValueListImpl;
for (const ShadowData *s = shadow; s; s = s->next) {
CSSPrimitiveValueImpl *x = new CSSPrimitiveValueImpl(s->x, CSSPrimitiveValue::CSS_PX);
CSSPrimitiveValueImpl *y = new CSSPrimitiveValueImpl(s->y, CSSPrimitiveValue::CSS_PX);
CSSPrimitiveValueImpl *blur = new CSSPrimitiveValueImpl(s->blur, CSSPrimitiveValue::CSS_PX);
CSSPrimitiveValueImpl *color = new CSSPrimitiveValueImpl(s->color.rgb());
list->append(new ShadowValueImpl(x, y, blur, color));
}
return list;
}
static bool compareCounterActList(const CSSValueListImpl *ca, const CSSValueListImpl *cb)
{
// weeee....
CSSValueListImpl *a = const_cast< CSSValueListImpl * >(ca);
CSSValueListImpl *b = const_cast< CSSValueListImpl * >(cb);
if(!a && !b)
return true;
if(!a || !b)
return false;
if(a->length() != b->length())
return false;
for(uint i = 0; i < a->length(); i++)
{
CSSValueImpl *ai = a->item(i);
CSSValueImpl *bi = b->item(i);
assert(ai && ai->cssValueType() == CSSValue::CSS_CUSTOM);
assert(bi && bi->cssValueType() == CSSValue::CSS_CUSTOM);
CounterActImpl *caa = static_cast< CounterActImpl * >(ai);
CounterActImpl *cab = static_cast< CounterActImpl * >(bi);
if(caa->value() != cab->value())
return false;
if(caa->counter() != cab->counter())
return false;
}
return true;
}
static bool parseAspectRatio(CSSValueImpl* value, int& h, int& v)
{
if (value->isValueList()){
CSSValueListImpl* valueList = static_cast<CSSValueListImpl*>(value);
if (valueList->length() == 3) {
CSSValueImpl* i0 = valueList->item(0);
CSSValueImpl* i1 = valueList->item(1);
CSSValueImpl* i2 = valueList->item(2);
if (i0->isPrimitiveValue() && static_cast<CSSPrimitiveValueImpl*>(i0)->primitiveType() == CSSPrimitiveValue::CSS_NUMBER
&& i1->isPrimitiveValue() && static_cast<CSSPrimitiveValueImpl*>(i1)->primitiveType() == CSSPrimitiveValue::CSS_STRING
&& i2->isPrimitiveValue() && static_cast<CSSPrimitiveValueImpl*>(i2)->primitiveType() == CSSPrimitiveValue::CSS_NUMBER) {
DOMString str = static_cast<CSSPrimitiveValueImpl*>(i1)->getStringValue();
if (!str.isNull() && str.length() == 1 && str[0] == '/') {
h = (int)static_cast<CSSPrimitiveValueImpl*>(i0)->floatValue(CSSPrimitiveValue::CSS_NUMBER);
v = (int)static_cast<CSSPrimitiveValueImpl*>(i2)->floatValue(CSSPrimitiveValue::CSS_NUMBER);
return true;
}
}
}
}
return false;
}
void CSSFontSelector::addFontFaceRule(const CSSFontFaceRuleImpl *fontFaceRule)
{
// Obtain the font-family property and the src property. Both must be defined.
const CSSStyleDeclarationImpl *style = fontFaceRule->style();
CSSValueImpl *fontFamily = style->getPropertyCSSValue(CSS_PROP_FONT_FAMILY);
CSSValueImpl *src = style->getPropertyCSSValue(CSS_PROP_SRC);
CSSValueImpl *unicodeRange = style->getPropertyCSSValue(CSS_PROP_UNICODE_RANGE);
if (!fontFamily || !src || !fontFamily->isValueList() || !src->isValueList() || (unicodeRange && !unicodeRange->isValueList())) {
return;
}
CSSValueListImpl *familyList = static_cast<CSSValueListImpl *>(fontFamily);
if (!familyList->length()) {
return;
}
CSSValueListImpl *srcList = static_cast<CSSValueListImpl *>(src);
if (!srcList->length()) {
return;
}
// CSSValueListImpl* rangeList = static_cast<CSSValueListImpl*>(unicodeRange);
unsigned traitsMask = 0;
/*
if (CSSValueImpl* fontStyle = style->getPropertyCSSValue(CSS_PROP_FONT_STYLE)) {
if (fontStyle->isPrimitiveValue()) {
CSSValueListImpl* list = new CSSValueListImpl(CSSValueListImpl::Comma);
list->append(fontStyle);
fontStyle = list;
} else if (!fontStyle->isValueList())
return;
CSSValueListImpl* styleList = static_cast<CSSValueListImpl*>(fontStyle);
unsigned numStyles = styleList->length();
if (!numStyles)
return;
for (unsigned i = 0; i < numStyles; ++i) {
switch (static_cast<CSSPrimitiveValueImpl*>(styleList[i])->getIdent()) {
case CSS_ALL:
traitsMask |= FontStyleMask;
break;
case CSS_NORMAL:
traitsMask |= FontStyleNormalMask;
break;
case CSS_ITALIC:
case CSS_OBLIQUE:
traitsMask |= FontStyleItalicMask;
break;
default:
break;
}
}
} else
traitsMask |= FontStyleMask;
if (CSSValueImpl* fontWeight = style->getPropertyCSSValue(CSS_PROP_FONT_WEIGHT)) {
if (fontWeight->isPrimitiveValue()) {
CSSValueListImpl* list = new CSSValueListImpl(CSSValueListImpl::Comma);
list->append(fontWeight);
fontWeight = list;
} else if (!fontWeight->isValueList())
return;
CSSValueListImpl* weightList = static_cast<CSSValueListImpl*>(fontWeight);
unsigned numWeights = weightList->length();
if (!numWeights)
return;
for (unsigned i = 0; i < numWeights; ++i) {
switch (static_cast<CSSPrimitiveValueImpl*>(weightList[i])->getIdent()) {
case CSS_VAL_ALL:
traitsMask |= FontWeightMask;
break;
case CSS_VAL_BOLDER:
case CSS_VAL_BOLD:
case CSS_VAL_700:
traitsMask |= FontWeight700Mask;
break;
case CSS_VAL_NORMAL:
case CSS_VAL_400:
traitsMask |= FontWeight400Mask;
break;
case CSS_VAL_900:
traitsMask |= FontWeight900Mask;
break;
case CSS_VAL_800:
traitsMask |= FontWeight800Mask;
break;
case CSS_VAL_600:
traitsMask |= FontWeight600Mask;
break;
case CSS_VAL_500:
traitsMask |= FontWeight500Mask;
break;
case CSS_VAL_300:
traitsMask |= FontWeight300Mask;
break;
case CSS_VAL_LIGHTER:
case CSS_VAL_200:
traitsMask |= FontWeight200Mask;
break;
case CSS_VAL_100:
traitsMask |= FontWeight100Mask;
break;
default:
break;
}
}
} else
traitsMask |= FontWeightMask;
if (CSSValueImpl* fontVariant = style->getPropertyCSSValue(CSS_PROP_FONT_VARIANT)) {
if (fontVariant->isPrimitiveValue()) {
CSSValueListImpl* list = new CSSValueListImpl(CSSValueListImpl::Comma);
list->append(fontVariant);
fontVariant = list;
} else if (!fontVariant->isValueList())
return;
CSSValueListImpl* variantList = static_cast<CSSValueListImpl*>(fontVariant);
unsigned numVariants = variantList->length();
if (!numVariants)
return;
for (unsigned i = 0; i < numVariants; ++i) {
switch (static_cast<CSSPrimitiveValueImpl*>(variantList[i])->getIdent()) {
case CSS_VAL_ALL:
traitsMask |= FontVariantMask;
break;
case CSS_VAL_NORMAL:
traitsMask |= FontVariantNormalMask;
break;
case CSS_VAL_SMALL_CAPS:
traitsMask |= FontVariantSmallCapsMask;
break;
default:
break;
}
}
} else
traitsMask |= FontVariantNormalMask;
*/
// Each item in the src property's list is a single CSSFontFaceSource. Put them all into a CSSFontFace.
CSSFontFace *fontFace = 0;
const int srcLength = srcList->length();
#if 0
// ENABLE(SVG_FONTS)
bool foundSVGFont = false;
#endif
for (int i = 0; i < srcLength; i++) {
// An item in the list either specifies a string (local font name) or a URL (remote font to download).
CSSFontFaceSrcValueImpl *item = static_cast<CSSFontFaceSrcValueImpl *>(srcList->item(i));
CSSFontFaceSource *source = 0;
#if 0
// ENABLE(SVG_FONTS)
foundSVGFont = item->isSVGFontFaceSrc() || item->svgFontFaceElement();
#endif
if (!item->isLocal()) {
if (item->isSupportedFormat() && m_document) {
source = new CSSFontFaceSource(item->resource(), true /*distant*/);
#if 0
// ENABLE(SVG_FONTS)
if (foundSVGFont) {
cachedFont->setSVGFont(true);
}
#endif
}
} else {
source = new CSSFontFaceSource(item->resource());
}
if (source) {
#if 0
// ENABLE(SVG_FONTS)
source->setSVGFontFaceElement(item->svgFontFaceElement());
#endif
if (!fontFace) {
fontFace = new CSSFontFace(static_cast<FontTraitsMask>(traitsMask), this);
}
fontFace->addSource(source);
}
}
if (!fontFace || !fontFace->isValid()) {
delete fontFace;
return;
}
/*
if (rangeList) {
unsigned numRanges = rangeList->length();
for (unsigned i = 0; i < numRanges; i++) {
CSSUnicodeRangeValueImpl* range = static_cast<CSSUnicodeRangeValueImpl*>(rangeList->item(i));
fontFace->addRange(range->from(), range->to());
}
}
*/
// Hash under every single family name.
int familyLength = familyList->length();
for (int i = 0; i < familyLength; i++) {
CSSPrimitiveValueImpl *item = static_cast<CSSPrimitiveValueImpl *>(familyList->item(i));
DOMString familyName;
if (item->primitiveType() == CSSPrimitiveValue::CSS_STRING) {
familyName = DOMString(static_cast<FontFamilyValueImpl *>(item)->fontName());
} else if (item->primitiveType() == CSSPrimitiveValue::CSS_IDENT) {
// We need to use the raw text for all the generic family types, since @font-face is a way of actually
// defining what font to use for those types.
switch (item->getIdent()) {
case CSS_VAL_SERIF:
familyName = "-khtml-serif";
break;
case CSS_VAL_SANS_SERIF:
familyName = "-khtml-sans-serif";
break;
case CSS_VAL_CURSIVE:
familyName = "-khtml-cursive";
break;
case CSS_VAL_FANTASY:
familyName = "-khtml-fantasy";
break;
case CSS_VAL_MONOSPACE:
familyName = "-khtml-monospace";
break;
default:
break;
}
}
if (familyName.isEmpty()) {
continue;
}
fontFace->addFamilyName(familyName);
m_locallyInstalledFontFaces.insertMulti(familyName.lower(), fontFace);
fontFace->ref();
#if 0
// ENABLE(SVG_FONTS)
// SVG allows several <font> elements with the same font-family, differing only
// in ie. font-variant. Be sure to pick up the right one - in getFontData below.
if (foundSVGFont && (traitsMask & FontVariantSmallCapsMask)) {
familyName += "-webkit-svg-small-caps";
}
#endif
/*
Vector<RefPtr<CSSFontFace> >* familyFontFaces = m_fontFaces.get(familyName);
if (!familyFontFaces) {
familyFontFaces = new Vector<RefPtr<CSSFontFace> >;
m_fontFaces.set(familyName, familyFontFaces);
ASSERT(!m_locallyInstalledFontFaces.contains(familyName));
Vector<RefPtr<CSSFontFace> >* familyLocallyInstalledFaces;
Vector<unsigned> locallyInstalledFontsTraitsMasks;
fontCache()->getTraitsInFamily(familyName, locallyInstalledFontsTraitsMasks);
unsigned numLocallyInstalledFaces = locallyInstalledFontsTraitsMasks.size();
if (numLocallyInstalledFaces) {
familyLocallyInstalledFaces = new Vector<RefPtr<CSSFontFace> >;
m_locallyInstalledFontFaces.set(familyName, familyLocallyInstalledFaces);
for (unsigned i = 0; i < numLocallyInstalledFaces; ++i) {
RefPtr<CSSFontFace> locallyInstalledFontFace = CSSFontFace::create(static_cast<FontTraitsMask>(locallyInstalledFontsTraitsMasks[i]));
locallyInstalledFontFace->addSource(new CSSFontFaceSource(familyName));
ASSERT(locallyInstalledFontFace->isValid());
familyLocallyInstalledFaces->append(locallyInstalledFontFace);
}
}
}
familyFontFaces->append(fontFace);
*/
}
// Should be impossible, but in case empty/invalid family name makes it through...
if (fontFace->refCount() < 1) {
delete fontFace;
}
}