int XmlNamespaceTable::getNamespaceID(const DOMString& uri, bool readonly) { if (uri == XHTML_NAMESPACE) return xhtmlNamespace; if (uri.isEmpty()) return noNamespace; QString uriStr = uri.string(); if (!gNamespaceTable) { gNamespaceTable = new QDict<XmlNamespaceEntry>; gNamespaceTable->insert(XHTML_NAMESPACE, new XmlNamespaceEntry(xhtmlNamespace, XHTML_NAMESPACE)); } XmlNamespaceEntry* ns = gNamespaceTable->find(uriStr); if (ns) return ns->m_id; if (!readonly) { static int id = xhtmlNamespace+1; ns = new XmlNamespaceEntry(id++, uri); gNamespaceTable->insert(uriStr, ns); return ns->m_id; } return -1; }
void HTMLScriptElementImpl::insertedIntoDocument() { HTMLElementImpl::insertedIntoDocument(); assert(!m_cachedScript); if (m_createdByParser) return; TQString url = getAttribute(ATTR_SRC).string(); if (!url.isEmpty()) { TQString charset = getAttribute(ATTR_CHARSET).string(); m_cachedScript = getDocument()->docLoader()->requestScript(DOMString(url), charset); if (m_cachedScript) m_cachedScript->ref(this); return; } // If there's an empty script node, we shouldn't evaluate the script // because if a script is inserted afterwards (by setting text or innerText) // it should be evaluated, and evaluateScript only evaluates a script once. DOMString scriptString = text(); if (!scriptString.isEmpty()) evaluateScript(getDocument()->URL().url(), scriptString); }
DOMString QualifiedName::tagName() const { DOMString prefix = m_prefix.toString(); DOMString localName = m_localName.toString(); if (prefix.isEmpty()) return localName; return prefix + DOMString(":") + localName; }
void HTMLAppletElementImpl::attach() { KHTMLView* w = getDocument()->view(); #ifndef Q_WS_QWS // FIXME? DOMString codeBase = getAttribute( ATTR_CODEBASE ); DOMString code = getAttribute( ATTR_CODE ); if ( !codeBase.isEmpty() ) url = codeBase.string(); if ( !code.isEmpty() ) url = code.string(); if (!w || !w->part()->javaEnabled()) #endif m_renderAlternative = true; HTMLObjectBaseElementImpl::attach(); }
void ElementImpl::setAttribute(NodeImpl::Id id, const DOMString &value, const DOMString &qName, int &exceptioncode) { // NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly if(isReadOnly()) { exceptioncode = DOMException::NO_MODIFICATION_ALLOWED_ERR; return; } attributes()->setValue(id, value.implementation(), (qName.isEmpty() ? 0 : qName.implementation())); }
void ProspectiveTokenizer::emitCSSRule() { QString rule(m_cssRule.data(), m_cssRule.size()); if (rule.toLower() == "import" && !m_cssRuleValue.isEmpty()) { DOMString value = DOMString(m_cssRuleValue.data(), m_cssRuleValue.size()); DOMString url = parseURL(value); if (!url.isEmpty()) m_document->docLoader()->registerPreload( m_document->docLoader()->requestStyleSheet( m_urlToLoad, m_document->part()->encoding() ) ); // #### charset } m_cssRule.clear(); m_cssRuleValue.clear(); }
void XMLTokenizer::executeScripts() { // Iterate through all of the html <script> tags in the document. For those that have a src attribute, // start loading the script and return (executeScripts() will be called again once the script is loaded // and continue where it left off). For scripts that don't have a src attribute, execute the code // inside the tag while(m_scriptsIt->current()) { DOMString scriptSrc = m_scriptsIt->current()->getAttribute(ATTR_SRC); QString charset = m_scriptsIt->current()->getAttribute(ATTR_CHARSET).string(); if(!scriptSrc.isEmpty()) { // we have a src attribute m_cachedScript = m_doc->docLoader()->requestScript(scriptSrc, charset); ++(*m_scriptsIt); if(m_cachedScript) { m_cachedScript->ref(this); // will call executeScripts() again if already cached return; } } else { // no src attribute - execute from contents of tag QString scriptCode = ""; NodeImpl *child; for(child = m_scriptsIt->current()->firstChild(); child; child = child->nextSibling()) { if((child->nodeType() == Node::TEXT_NODE || child->nodeType() == Node::CDATA_SECTION_NODE) && static_cast< TextImpl * >(child)->string()) scriptCode += QConstString(static_cast< TextImpl * >(child)->string()->s, static_cast< TextImpl * >(child)->string()->l).string(); } // the script cannot do document.write until we support incremental parsing // ### handle the case where the script deletes the node or redirects to // another page, etc. (also in notifyFinished()) // ### the script may add another script node after this one which should be executed if(m_view) { m_view->part()->executeScript(DOM::Node(), scriptCode); } ++(*m_scriptsIt); } } // All scripts have finished executing, so calculate the style for the document and close // the last element m_doc->updateStyleSelector(); // We are now finished parsing end(); }
void MediaListImpl::setMediaText(const DOM::DOMString &value) { m_lstMedia.clear(); const QString val = value.string(); const QStringList list = QStringList::split( ',', val ); const QStringList::ConstIterator itEnd = list.end(); for ( QStringList::ConstIterator it = list.begin(); it != itEnd; ++it ) { const DOMString medium = (*it).stripWhiteSpace(); if( !medium.isEmpty() ) m_lstMedia.append( medium ); } }
void HTMLBRElementImpl::parseAttribute(AttributeImpl *attr) { switch(attr->id()) { case ATTR_CLEAR: { DOMString str = attr->value(); if( str.isEmpty() ) str = "none"; else if( strcasecmp (str,"all")==0 ) str = "both"; addCSSProperty(CSS_PROP_CLEAR, str); break; } default: HTMLElementImpl::parseAttribute(attr); } }
void RenderImage::updateFromElement() { if (element()->id() == ID_INPUT) alt = static_cast<HTMLInputElementImpl*>(element())->altText(); else if (element()->id() == ID_IMG) alt = static_cast<HTMLImageElementImpl*>(element())->altText(); DOMString u = element()->id() == ID_OBJECT ? element()->getAttribute(ATTR_DATA) : element()->getAttribute(ATTR_SRC); if (!u.isEmpty() && ( !m_cachedImage || m_cachedImage->url() != u ) ) { CachedImage *new_image = element()->document()->docLoader()-> requestImage(khtml::parseURL(u)); if(new_image && new_image != m_cachedImage) updateImage( new_image ); } }
void RenderPartObject::updateWidget() { QString url; QString serviceType; QStringList params; KHTMLPart *part = m_view->part(); setNeedsLayoutAndMinMaxRecalc(); if (element()->id() == ID_OBJECT) { HTMLObjectElementImpl *o = static_cast<HTMLObjectElementImpl *>(element()); // Check for a child EMBED tag. HTMLEmbedElementImpl *embed = 0; for (NodeImpl *child = o->firstChild(); child; child = child->nextSibling()) { if (child->id() == ID_EMBED) { embed = static_cast<HTMLEmbedElementImpl *>( child ); break; } } // Use the attributes from the EMBED tag instead of the OBJECT tag including WIDTH and HEIGHT. HTMLElementImpl *embedOrObject; if (embed) { embedOrObject = (HTMLElementImpl *)embed; DOMString attribute = embedOrObject->getAttribute(ATTR_WIDTH); if (!attribute.isEmpty()) { o->setAttribute(ATTR_WIDTH, attribute); } attribute = embedOrObject->getAttribute(ATTR_HEIGHT); if (!attribute.isEmpty()) { o->setAttribute(ATTR_HEIGHT, attribute); } url = embed->url; serviceType = embed->serviceType; } else { embedOrObject = (HTMLElementImpl *)o; } // If there was no URL or type defined in EMBED, try the OBJECT tag. if (url.isEmpty()) { url = o->url; } if (serviceType.isEmpty()) { serviceType = o->serviceType; } // Then try the PARAM tags for the URL and type attributes. NodeImpl *child = o->firstChild(); while (child && (url.isEmpty() || serviceType.isEmpty())) { if (child->id() == ID_PARAM) { HTMLParamElementImpl *p = static_cast<HTMLParamElementImpl *>( child ); QString name = p->name().lower(); if (url.isEmpty() && (QString::equals(name,"src") || QString::equals(name,"movie") || QString::equals(name,"code"))) { url = p->value(); } if (serviceType.isEmpty() && QString::equals(name,"type")) { serviceType = p->value(); } } child = child->nextSibling(); } // Lastly try to map a specific CLASSID to a type. if (serviceType.isEmpty() && !o->classId.isEmpty()) { if (o->classId.contains("D27CDB6E-AE6D-11cf-96B8-444553540000")) { // It is ActiveX, but the nsplugin system handling // should also work, that's why we don't override the // serviceType with application/x-activex-handler // but let the KTrader in khtmlpart::createPart() detect // the user's preference: launch with activex viewer or // with nspluginviewer (Niko) serviceType = "application/x-shockwave-flash"; } else if(o->classId.contains("CFCDAA03-8BE4-11cf-B84B-0020AFBBCCFA")) { serviceType = "audio/x-pn-realaudio-plugin"; } else if(o->classId.contains("02BF25D5-8C17-4B23-BC80-D3488ABDDC6B")) { serviceType = "video/quicktime"; } else if(o->classId.contains("166B1BCA-3F9C-11CF-8075-444553540000")) { serviceType = "application/x-director"; } else { // We have a clsid, means this is activex (Niko) serviceType = "application/x-activex-handler"; } // TODO: add more plugins here } // If no URL and type, abort. if (url.isEmpty() && serviceType.isEmpty()) { #ifdef DEBUG_LAYOUT kdDebug() << "RenderPartObject::close - empty url and serverType" << endl; #endif return; } // Turn the attributes of either the EMBED tag or OBJECT tag into an array. NamedAttrMapImpl* attributes = embedOrObject->attributes(); if (attributes) { for (unsigned long i = 0; i < attributes->length(); ++i) { AttributeImpl* it = attributes->attributeItem(i); params.append(o->getDocument()->attrName(it->id()).string() + "=\"" + it->value().string() + "\""); } } params.append( QString::fromLatin1("__KHTML__CLASSID=\"%1\"").arg( o->classId ) ); params.append( QString::fromLatin1("__KHTML__CODEBASE=\"%1\"").arg( o->getAttribute(ATTR_CODEBASE).string() ) ); part->requestObject( this, url, serviceType, params ); } else if ( element()->id() == ID_EMBED ) { HTMLEmbedElementImpl *o = static_cast<HTMLEmbedElementImpl *>(element()); url = o->url; serviceType = o->serviceType; if ( url.isEmpty() && serviceType.isEmpty() ) { #ifdef DEBUG_LAYOUT kdDebug() << "RenderPartObject::close - empty url and serverType" << endl; #endif return; } // add all attributes set on the embed object NamedAttrMapImpl* a = o->attributes(); if (a) { for (unsigned long i = 0; i < a->length(); ++i) { AttributeImpl* it = a->attributeItem(i); params.append(o->getDocument()->attrName(it->id()).string() + "=\"" + it->value().string() + "\""); } } part->requestObject( this, url, serviceType, params ); } else { assert(element()->id() == ID_IFRAME); HTMLIFrameElementImpl *o = static_cast<HTMLIFrameElementImpl *>(element()); url = o->url.string(); if (url.isEmpty()) url = "about:blank"; KHTMLView *v = static_cast<KHTMLView *>(m_view); bool requestSucceeded = v->part()->requestFrame( this, url, o->name.string(), QStringList(), true ); if (requestSucceeded && QString::equals(url,"about:blank")) { KHTMLPart *newPart = v->part()->findFrame( o->name.string() ); if (newPart && newPart->xmlDocImpl()) { newPart->xmlDocImpl()->setBaseURL( v->part()->baseURL().url() ); } } } }
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; } }
bool MediaQueryEvaluator::mediaTypeMatch(const DOMString& mediaTypeToMatch) const { return mediaTypeToMatch.isEmpty() || !strcasecmp("all", mediaTypeToMatch) || !strcasecmp(m_mediaType, mediaTypeToMatch); }