MediaQueryEvaluator:: MediaQueryEvaluator(const DOMString& acceptedMediaType, KHTMLPart* part, RenderStyle* style) : m_mediaType(acceptedMediaType.lower()) , m_part(part) , m_style(style) , m_expResult(false) // doesn't matter when we have m_part and m_style { }
void HTMLDocumentImpl::setDomain(const DOMString &newDomain) { if ( m_domain.isEmpty() ) // not set yet (we set it on demand to save time and space) m_domain = KURL(URL()).host().lower(); // Initially set to the host if ( m_domain.isEmpty() /*&& view() && view()->part()->openedByJS()*/ ) m_domain = newDomain.lower(); // Both NS and IE specify that changing the domain is only allowed when // the new domain is a suffix of the old domain. int oldLength = m_domain.length(); int newLength = newDomain.length(); if ( newLength < oldLength ) // e.g. newDomain=kde.org (7) and m_domain=www.kde.org (11) { DOMString test = m_domain.copy(); DOMString reference = newDomain.lower(); if ( test[oldLength - newLength - 1] == '.' ) // Check that it's a subdomain, not e.g. "de.org" { test.remove( 0, oldLength - newLength ); // now test is "kde.org" from m_domain if ( test == reference ) // and we check that it's the same thing as newDomain m_domain = reference; } } }
void CSSFontSelector::requestFamilyName(const DOMString &familyName) { QHash<DOMString, CSSFontFace*>::const_iterator it = m_locallyInstalledFontFaces.constBegin(); QHash<DOMString, CSSFontFace*>::const_iterator end = m_locallyInstalledFontFaces.constEnd(); if (it == end) { return; } const DOMString familyNameLower = familyName.lower(); do { if (it.key() == familyNameLower) { it.value()->refLoaders(); } ++it; } while (it != end); }
DOMString AttrImpl::name() const { DOMString n = getDocument()->getName(AttributeId, m_attrId); // compat mode always return attribute names in lowercase. // that's not formally in the specification, but common // practice - a w3c erratum to DOM L2 is pending. if(m_htmlCompat) n = n.lower(); if(m_prefix && m_prefix->l) return DOMString(m_prefix) + ":" + n; return n; }
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; } }