void SVGStyledElement::synchronizeProperty(const QualifiedName& attrName)
{
SVGElement::synchronizeProperty(attrName);
if (attrName == anyQName() || attrName.matches(HTMLNames::classAttr))
synchronizeClassName();
}
void AXObjectCache::handleAttributeChanged(const QualifiedName& attrName, Element* element)
{
if (attrName == roleAttr)
handleAriaRoleChanged(element);
else if (attrName == altAttr || attrName == titleAttr)
textChanged(element);
else if (attrName == forAttr && element->hasTagName(labelTag))
labelChanged(element);
if (!attrName.localName().string().startsWith("aria-"))
return;
if (attrName == aria_activedescendantAttr)
handleActiveDescendantChanged(element);
else if (attrName == aria_valuenowAttr || attrName == aria_valuetextAttr)
postNotification(element, AXObjectCache::AXValueChanged, true);
else if (attrName == aria_labelAttr || attrName == aria_labeledbyAttr || attrName == aria_labelledbyAttr)
textChanged(element);
else if (attrName == aria_checkedAttr)
checkedStateChanged(element);
else if (attrName == aria_selectedAttr)
selectedChildrenChanged(element);
else if (attrName == aria_expandedAttr)
handleAriaExpandedChange(element);
else if (attrName == aria_hiddenAttr)
childrenChanged(element->parentNode());
else if (attrName == aria_invalidAttr)
postNotification(element, AXObjectCache::AXInvalidStatusChanged, true);
else
postNotification(element, AXObjectCache::AXAriaAttributeChanged, true);
}
void SVGStyledElement::svgAttributeChanged(const QualifiedName& attrName)
{
SVGElement::svgAttributeChanged(attrName);
if (attrName.matches(HTMLNames::classAttr))
classAttributeChanged(className());
RenderObject* object = renderer();
if (attrName == idAttributeName()) {
// Notify resources about id changes, this is important as we cache resources by id in SVGDocumentExtensions
if (object && object->isSVGResourceContainer())
object->toRenderSVGResourceContainer()->idChanged();
}
if (!document()->parsing() && object) {
// If we're the child of a resource element, tell the resource (and eventually its resources) that we've changed.
invalidateResourcesInAncestorChain();
// If we're referencing resources, tell them we've changed.
deregisterFromResources(object);
}
// Invalidate all SVGElementInstances associated with us
SVGElementInstance::invalidateAllInstancesOfElement(this);
}
static CSSPropertyID cssPropertyIdForFontFaceAttributeName(const QualifiedName& attrName)
{
if (!attrName.namespaceURI().isNull())
return CSSPropertyInvalid;
static HashMap<StringImpl*, CSSPropertyID>* propertyNameToIdMap = 0;
if (!propertyNameToIdMap) {
propertyNameToIdMap = new HashMap<StringImpl*, CSSPropertyID>;
// This is a list of all @font-face CSS properties which are exposed as SVG XML attributes
// Those commented out are not yet supported by WebCore's style system
// mapAttributeToCSSProperty(propertyNameToIdMap, accent_heightAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, alphabeticAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, ascentAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, bboxAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, cap_heightAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, descentAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, font_familyAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, font_sizeAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, font_stretchAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, font_styleAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, font_variantAttr);
mapAttributeToCSSProperty(propertyNameToIdMap, font_weightAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, hangingAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, ideographicAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, mathematicalAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, overline_positionAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, overline_thicknessAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, panose_1Attr);
// mapAttributeToCSSProperty(propertyNameToIdMap, slopeAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, stemhAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, stemvAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, strikethrough_positionAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, strikethrough_thicknessAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, underline_positionAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, underline_thicknessAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, unicode_rangeAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, units_per_emAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, v_alphabeticAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, v_hangingAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, v_ideographicAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, v_mathematicalAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, widthsAttr);
// mapAttributeToCSSProperty(propertyNameToIdMap, x_heightAttr);
}
return propertyNameToIdMap->get(attrName.localName().impl());
}
QualifiedName * CmpSqlSession::updateVolatileQualifiedName(const NAString &inName)
{
QualifiedName *result = NULL;
if (volatileSchemaInUse_)
{
result = new (heap_)
QualifiedName(inName,
volatileSchemaName(), volatileCatalogName(), heap_);
CMPASSERT(result);
result->setIsVolatile(TRUE);
}
return result;
}
void CustomElementReactionQueue::enqueueAttributeChangedCallbackIfNeeded(Element& element, const QualifiedName& attributeName, const AtomicString& oldValue, const AtomicString& newValue)
{
ASSERT(element.isDefinedCustomElement());
ASSERT(element.document().refCount() > 0);
auto& queue = CustomElementReactionStack::ensureCurrentQueue(element);
if (queue.m_interface->observesAttribute(attributeName.localName()))
queue.m_items.append({attributeName, oldValue, newValue});
}
void SVGAnimationElement::setTargetAttributeAnimatedValue(const String& value)
{
if (!hasValidAttributeType())
return;
SVGElement* targetElement = this->targetElement();
QualifiedName attributeName = this->attributeName();
if (!targetElement || attributeName == anyQName() || value.isNull())
return;
// We don't want the instance tree to get rebuild. Instances are updated in the loop below.
if (targetElement->isStyled())
static_cast<SVGStyledElement*>(targetElement)->setInstanceUpdatesBlocked(true);
bool attributeIsCSSProperty = isTargetAttributeCSSProperty(targetElement, attributeName);
// Stop animation, if attributeType is set to CSS by the user, but the attribute itself is not a CSS property.
if (!attributeIsCSSProperty && attributeType() == AttributeTypeCSS)
return;
ExceptionCode ec;
if (attributeIsCSSProperty) {
// FIXME: This should set the override style, not the inline style.
// Sadly override styles are not yet implemented.
targetElement->style()->setProperty(attributeName.localName(), value, "", ec);
} else {
// FIXME: This should set the 'presentation' value, not the actual
// attribute value. Whatever that means in practice.
targetElement->setAttribute(attributeName, value, ec);
}
if (targetElement->isStyled())
static_cast<SVGStyledElement*>(targetElement)->setInstanceUpdatesBlocked(false);
// If the target element is used in an <use> instance tree, update that as well.
const HashSet<SVGElementInstance*>& instances = targetElement->instancesForElement();
const HashSet<SVGElementInstance*>::const_iterator end = instances.end();
for (HashSet<SVGElementInstance*>::const_iterator it = instances.begin(); it != end; ++it) {
SVGElement* shadowTreeElement = (*it)->shadowTreeElement();
if (!shadowTreeElement)
continue;
if (attributeIsCSSProperty)
shadowTreeElement->style()->setProperty(attributeName.localName(), value, "", ec);
else
shadowTreeElement->setAttribute(attributeName, value, ec);
(*it)->correspondingUseElement()->setNeedsStyleRecalc();
}
}
void ScriptCustomElementDefinition::runAttributeChangedCallback(
Element* element,
const QualifiedName& name,
const AtomicString& oldValue,
const AtomicString& newValue) {
if (!m_scriptState->contextIsValid())
return;
ScriptState::Scope scope(m_scriptState.get());
v8::Isolate* isolate = m_scriptState->isolate();
v8::Local<v8::Value> argv[] = {
v8String(isolate, name.localName()), v8StringOrNull(isolate, oldValue),
v8StringOrNull(isolate, newValue),
v8StringOrNull(isolate, name.namespaceURI()),
};
runCallback(m_attributeChangedCallback.newLocal(isolate), element,
WTF_ARRAY_LENGTH(argv), argv);
}
void Element::setBooleanAttribute(const QualifiedName& name, bool b)
{
if (b)
setAttribute(name, name.localName());
else {
ExceptionCode ex;
removeAttribute(name, ex);
}
}
NABoolean isHBaseMeta(const QualifiedName& qualifiedName)
{
return
( HSGlobalsClass::isHBaseMeta(
qualifiedName.getUnqualifiedSchemaNameAsAnsiString()
) ||
isHBaseUmdHistograms(qualifiedName)
);
}
bool SVGURIReference::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (name.matches(XLinkNames::hrefAttr)) {
setHrefBaseValue(value);
return true;
}
return false;
}
QualifiedName * CmpSqlSession::updateVolatileQualifiedName(QualifiedName &inName)
{
QualifiedName *result = &inName;
if (volatileSchemaInUse_)
{
result = new (heap_)
QualifiedName(inName.getObjectName(),
volatileSchemaName(), volatileCatalogName(), heap_);
CMPASSERT(result);
result->setNamePosition(inName.getNamePosition());
result->setIsVolatile(TRUE);
}
return result;
}
PassRefPtrWillBeRawPtr<Element> CustomElementRegistrationContext::createCustomTagElement(Document& document, const QualifiedName& tagName)
{
ASSERT(CustomElement::isValidName(tagName.localName()));
RefPtrWillBeRawPtr<Element> element;
if (HTMLNames::xhtmlNamespaceURI == tagName.namespaceURI()) {
element = HTMLElement::create(tagName, document);
} else if (SVGNames::svgNamespaceURI == tagName.namespaceURI()) {
element = SVGUnknownElement::create(tagName, document);
} else {
// XML elements are not custom elements, so return early.
return Element::create(tagName, &document);
}
element->setCustomElementState(Element::WaitingForUpgrade);
resolveOrScheduleResolution(element.get(), nullAtom);
return element.release();
}
void MarkupAccumulator::appendAttribute(StringBuilder& result, const Element& element, const Attribute& attribute, Namespaces* namespaces)
{
bool documentIsHTML = serializeAsHTMLDocument(element);
QualifiedName prefixedName = attribute.name();
if (documentIsHTML && !attributeIsInSerializedNamespace(attribute)) {
result.append(' ');
result.append(attribute.name().localName());
} else {
if (attribute.namespaceURI() == XLinkNames::xlinkNamespaceURI) {
if (!attribute.prefix())
prefixedName.setPrefix(xlinkAtom);
} else if (attribute.namespaceURI() == XMLNames::xmlNamespaceURI) {
if (!attribute.prefix())
prefixedName.setPrefix(xmlAtom);
} else if (attribute.namespaceURI() == XMLNSNames::xmlnsNamespaceURI) {
if (!attribute.prefix() && attribute.localName() != xmlnsAtom)
prefixedName.setPrefix(xmlnsAtom);
if (namespaces) { // Account for the namespace attribute we're about to append.
const AtomicString& lookupKey = (!attribute.prefix()) ? emptyAtom : attribute.localName();
namespaces->set(lookupKey, attribute.value());
}
} else if (namespaces && shouldAddNamespaceAttribute(attribute, element)) {
if (!attribute.prefix()) {
// This behavior is in process of being standardized. See crbug.com/248044 and https://www.w3.org/Bugs/Public/show_bug.cgi?id=24208
String prefixPrefix("ns", 2);
for (unsigned i = attribute.namespaceURI().impl()->existingHash(); ; ++i) {
AtomicString newPrefix(String(prefixPrefix + String::number(i)));
AtomicString foundURI = namespaces->get(newPrefix);
if (foundURI == attribute.namespaceURI() || foundURI == nullAtom) {
// We already generated a prefix for this namespace.
prefixedName.setPrefix(newPrefix);
break;
}
}
}
ASSERT(prefixedName.prefix());
appendNamespace(result, prefixedName.prefix(), attribute.namespaceURI(), *namespaces);
}
result.append(' ');
result.append(prefixedName.toString());
}
result.append('=');
if (element.isURLAttribute(attribute)) {
appendQuotedURLAttributeValue(result, element, attribute);
} else {
result.append('"');
appendAttributeValue(result, attribute.value(), documentIsHTML);
result.append('"');
}
}
static bool findAttributeWithName(const HTMLToken& token, const QualifiedName& name, size_t& indexOfMatchingAttribute)
{
for (size_t i = 0; i < token.attributes().size(); ++i) {
if (equalIgnoringNullity(token.attributes().at(i).m_name, name.localName())) {
indexOfMatchingAttribute = i;
return true;
}
}
return false;
}
PassRefPtr<SVGElement> SVGElementFactory::createElement(const QualifiedName& name, Document& document, bool createdByParser)
{
static NeverDestroyed<HashMap<AtomicStringImpl*, SVGConstructorFunction>> functions;
if (functions.get().isEmpty())
populateSVGFactoryMap(functions);
if (SVGConstructorFunction function = functions.get().get(name.localName().impl())) {
if (RefPtr<SVGElement> element = function(name, document, createdByParser))
return element.release();
}
return SVGUnknownElement::create(name, document);
}
PassRefPtr<HTMLElement> HTMLElementFactory::createHTMLElement(const QualifiedName& qName, Document* document, HTMLFormElement* formElement, bool createdByParser)
{
if (!document)
return 0;
if (!gFunctionMap)
createFunctionMap();
if (ConstructorFunction function = gFunctionMap->get(qName.localName().impl()))
return function(qName, document, formElement, createdByParser);
return HTMLElement::create(qName, document);
}
PassRefPtr<CustomElementConstructor> CustomElementRegistry::find(const QualifiedName& typeName, const QualifiedName& localName) const
{
ConstructorMap::const_iterator found = m_constructors.end();
if (!typeName.localName().isEmpty())
found = m_constructors.find(std::make_pair(typeName, localName));
if (found == m_constructors.end())
found = m_constructors.find(std::make_pair(localName, localName));
if (found == m_constructors.end())
return 0;
return found->value;
}
String SMILTimeContainer::baseValueFor(ElementAttributePair key)
{
// FIXME: We wouldn't need to do this if we were keeping base values around properly in DOM.
// Currently animation overwrites them so we need to save them somewhere.
BaseValueMap::iterator it = m_savedBaseValues.find(key);
if (it != m_savedBaseValues.end())
return it->second;
SVGElement* targetElement = key.first;
QualifiedName attributeName = key.second;
ASSERT(targetElement);
ASSERT(attributeName != anyQName());
String baseValue;
if (SVGAnimationElement::isTargetAttributeCSSProperty(targetElement, attributeName))
baseValue = computedStyle(targetElement)->getPropertyValue(cssPropertyID(attributeName.localName()));
else
baseValue = targetElement->getAttribute(attributeName);
m_savedBaseValues.add(key, baseValue);
return baseValue;
}
void SVGTextContentElement::collectStyleForPresentationAttribute(const QualifiedName& name, const AtomicString& value, MutableStyleProperties& style)
{
if (!isSupportedAttribute(name))
SVGGraphicsElement::collectStyleForPresentationAttribute(name, value, style);
else if (name.matches(XMLNames::spaceAttr)) {
DEPRECATED_DEFINE_STATIC_LOCAL(const AtomicString, preserveString, ("preserve", AtomicString::ConstructFromLiteral));
if (value == preserveString)
addPropertyToPresentationAttributeStyle(style, CSSPropertyWhiteSpace, CSSValuePre);
else
addPropertyToPresentationAttributeStyle(style, CSSPropertyWhiteSpace, CSSValueNowrap);
}
PassRefPtr<Element> CustomElementRegistry::createElement(const QualifiedName& localName, const AtomicString& typeExtension) const
{
const QualifiedName& typeName = QualifiedName(nullAtom, typeExtension, localName.namespaceURI());
if (RefPtr<CustomElementConstructor> found = find(typeName, localName)) {
RefPtr<Element> created = found->createElement();
if (!typeName.localName().isEmpty() && localName != typeName)
return setTypeExtension(created, typeExtension);
return created.release();
}
return 0;
}
void HTMLElement::collectStyleForPresentationAttribute(const QualifiedName& name, const AtomicString& value, MutableStylePropertySet* style)
{
if (name == alignAttr) {
if (equalIgnoringCase(value, "middle"))
addPropertyToPresentationAttributeStyle(style, CSSPropertyTextAlign, CSSValueCenter);
else
addPropertyToPresentationAttributeStyle(style, CSSPropertyTextAlign, value);
} else if (name == contenteditableAttr) {
if (value.isEmpty() || equalIgnoringCase(value, "true")) {
addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitUserModify, CSSValueReadWrite);
addPropertyToPresentationAttributeStyle(style, CSSPropertyWordWrap, CSSValueBreakWord);
addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitLineBreak, CSSValueAfterWhiteSpace);
UseCounter::count(document(), UseCounter::ContentEditableTrue);
if (hasTagName(htmlTag))
UseCounter::count(document(), UseCounter::ContentEditableTrueOnHTML);
} else if (equalIgnoringCase(value, "plaintext-only")) {
addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitUserModify, CSSValueReadWritePlaintextOnly);
addPropertyToPresentationAttributeStyle(style, CSSPropertyWordWrap, CSSValueBreakWord);
addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitLineBreak, CSSValueAfterWhiteSpace);
UseCounter::count(document(), UseCounter::ContentEditablePlainTextOnly);
} else if (equalIgnoringCase(value, "false")) {
addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitUserModify, CSSValueReadOnly);
}
} else if (name == hiddenAttr) {
addPropertyToPresentationAttributeStyle(style, CSSPropertyDisplay, CSSValueNone);
} else if (name == draggableAttr) {
if (equalIgnoringCase(value, "true")) {
addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitUserDrag, CSSValueElement);
addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitUserSelect, CSSValueNone);
} else if (equalIgnoringCase(value, "false")) {
addPropertyToPresentationAttributeStyle(style, CSSPropertyWebkitUserDrag, CSSValueNone);
}
} else if (name == dirAttr) {
if (equalIgnoringCase(value, "auto")) {
addPropertyToPresentationAttributeStyle(style, CSSPropertyUnicodeBidi, unicodeBidiAttributeForDirAuto(this));
} else {
if (isValidDirAttribute(value))
addPropertyToPresentationAttributeStyle(style, CSSPropertyDirection, value);
else
addPropertyToPresentationAttributeStyle(style, CSSPropertyDirection, "ltr");
if (!hasTagName(bdiTag) && !hasTagName(bdoTag) && !hasTagName(outputTag))
addPropertyToPresentationAttributeStyle(style, CSSPropertyUnicodeBidi, CSSValueIsolate);
}
} else if (name.matches(XMLNames::langAttr)) {
mapLanguageAttributeToLocale(value, style);
} else if (name == langAttr) {
// xml:lang has a higher priority than lang.
if (!fastHasAttribute(XMLNames::langAttr))
mapLanguageAttributeToLocale(value, style);
} else {
Element::collectStyleForPresentationAttribute(name, value, style);
}
}
void SVGAnimationElement::adjustForInheritance(SVGElement* targetElement, const QualifiedName& attributeName, String& value)
{
// FIXME: At the moment the computed style gets returned as a String and needs to get parsed again.
// In the future we might want to work with the value type directly to avoid the String parsing.
ASSERT(targetElement);
Element* parent = targetElement->parentElement();
if (!parent || !parent->isSVGElement())
return;
SVGElement* svgParent = toSVGElement(parent);
computeCSSPropertyValue(svgParent, cssPropertyID(attributeName.localName()), value);
}
void MarkupAccumulator::appendAttribute(StringBuilder& result, const Element& element, const Attribute& attribute, Namespaces* namespaces)
{
bool documentIsHTML = element.document().isHTMLDocument();
result.append(' ');
QualifiedName prefixedName = attribute.name();
if (documentIsHTML && !attributeIsInSerializedNamespace(attribute))
result.append(attribute.name().localName());
else {
if (!attribute.namespaceURI().isEmpty()) {
AtomicStringImpl* foundNS = namespaces && attribute.prefix().impl() ? namespaces->get(attribute.prefix().impl()) : 0;
bool prefixIsAlreadyMappedToOtherNS = foundNS && foundNS != attribute.namespaceURI().impl();
if (attribute.prefix().isEmpty() || !foundNS || prefixIsAlreadyMappedToOtherNS) {
if (AtomicStringImpl* prefix = namespaces ? namespaces->get(attribute.namespaceURI().impl()) : 0)
prefixedName.setPrefix(AtomicString(prefix));
else {
bool shouldBeDeclaredUsingAppendNamespace = !attribute.prefix().isEmpty() && !foundNS;
if (!shouldBeDeclaredUsingAppendNamespace && attribute.localName() != xmlnsAtom && namespaces)
generateUniquePrefix(prefixedName, *namespaces);
}
}
}
result.append(prefixedName.toString());
}
result.append('=');
if (element.isURLAttribute(attribute))
appendQuotedURLAttributeValue(result, element, attribute);
else {
result.append('"');
appendAttributeValue(result, attribute.value(), documentIsHTML);
result.append('"');
}
if ((inXMLFragmentSerialization() || !documentIsHTML) && namespaces && shouldAddNamespaceAttribute(attribute, *namespaces))
appendNamespace(result, prefixedName.prefix(), prefixedName.namespaceURI(), *namespaces);
}
static bool findAttributeWithName(const HTMLToken& token, const QualifiedName& name, size_t& indexOfMatchingAttribute)
{
// Notice that we're careful not to ref the StringImpl here because we might be on a background thread.
const String& attrName = name.namespaceURI() == XLinkNames::xlinkNamespaceURI ? "xlink:" + name.localName().string() : name.localName().string();
for (size_t i = 0; i < token.attributes().size(); ++i) {
if (equalIgnoringNullity(token.attributes().at(i).name, attrName)) {
indexOfMatchingAttribute = i;
return true;
}
}
return false;
}
PassRefPtr<JSLazyEventListener> JSLazyEventListener::createForDOMWindow(Frame& frame, const QualifiedName& attributeName, const AtomicString& attributeValue)
{
if (attributeValue.isNull())
return nullptr;
if (!frame.script().canExecuteScripts(AboutToExecuteScript))
return nullptr;
return adoptRef(new JSLazyEventListener(attributeName.localName().string(),
eventParameterName(frame.document()->isSVGDocument()), attributeValue,
nullptr, frame.document()->url().string(), frame.script().eventHandlerPosition(),
toJSDOMWindow(&frame, mainThreadNormalWorld()), mainThreadNormalWorld()));
}
void SVGElement::parseAttribute(const QualifiedName& name, const AtomicString& value)
{
if (name == HTMLNames::classAttr) {
// SVG animation has currently requires special storage of values so we set
// the className here. svgAttributeChanged actually causes the resulting
// style updates (instead of Element::parseAttribute). We don't
// tell Element about the change to avoid parsing the class list twice
SVGParsingError parseError = NoError;
m_className->setBaseValueAsString(value, parseError);
reportAttributeParsingError(parseError, name, value);
} else if (name.matches(XMLNames::langAttr) || name.matches(XMLNames::spaceAttr)) {
} else if (name == tabindexAttr) {
Element::parseAttribute(name, value);
} else {
// standard events
const AtomicString& eventName = HTMLElement::eventNameForAttributeName(name);
if (!eventName.isNull())
setAttributeEventListener(eventName, createAttributeEventListener(this, name, value, eventParameterName()));
else
Element::parseAttribute(name, value);
}
}
void SelectorDataList::collectElementsByTagName(ContainerNode& rootNode, const QualifiedName& tagName, typename SelectorQueryTrait::OutputType& output) const
{
for (Element& element : ElementTraversal::descendantsOf(rootNode)) {
// querySelector*() doesn't allow namespaces and throws before it gets
// here so we can ignore them.
ASSERT(tagName.namespaceURI() == starAtom);
if (matchesTagName(tagName, element)) {
SelectorQueryTrait::appendElement(output, element);
if (SelectorQueryTrait::shouldOnlyMatchFirstElement)
return;
}
}
}
// Convert a uaf::QualifiedName to a OpcUa_QualifiedName
// =============================================================================================
Status NamespaceArray::fillOpcUaQualifiedName(
const QualifiedName& qualifiedName,
OpcUa_QualifiedName& opcUaQualifiedName) const
{
Status ret;
// check if the browse name has a namespace URI for which we can find an index
if (qualifiedName.hasNameSpaceUri())
{
// we need to get a valid namespace index
NameSpaceIndex nameSpaceIndex;
if (findNamespaceIndex(qualifiedName.nameSpaceUri(), nameSpaceIndex))
{
// copy the contents from the qualified name to the SDK object
// (except the namespaceUri because that's not relevant for the SDK object anyway)
QualifiedName(qualifiedName.name(), nameSpaceIndex).toSdk(&opcUaQualifiedName);
ret = statuscodes::Good;
}
else
{
ret = UnknownNamespaceUriError();
}
}
else if (qualifiedName.hasNameSpaceIndex())
{
// OK we don't have a namespace URI but we do have a namespace index
qualifiedName.toSdk(&opcUaQualifiedName);
ret = statuscodes::Good;
}
else
{
// we have no possible means to get the namespace index
ret = NoNamespaceIndexOrUriGivenError();
}
return ret;
}
static inline void adjustForInheritance(SVGElement* targetElement, const QualifiedName& attributeName, String& value)
{
// FIXME: At the moment the computed style gets returned as a String and needs to get parsed again.
// In the future we might want to work with the value type directly to avoid the String parsing.
ASSERT(targetElement);
Element* parent = targetElement->parentElement();
if (!parent || !parent->isSVGElement())
return;
SVGElement* svgParent = static_cast<SVGElement*>(parent);
if (svgParent->isStyled())
value = computedStyle(svgParent)->getPropertyValue(cssPropertyID(attributeName.localName()));
}