void SVGAnimateElement::applyResultsToTarget()
{
ASSERT(animatedPropertyType() != AnimatedTransformList || isSVGAnimateTransformElement(*this));
ASSERT(animatedPropertyType() != AnimatedUnknown);
// Early exit if our animated type got destructed by a previous endedActiveInterval().
if (!m_animatedProperty)
return;
// We do update the style and the animation property independent of each other.
ShouldApplyAnimationType shouldApply = shouldApplyAnimation(targetElement(), attributeName());
if (shouldApply == ApplyXMLandCSSAnimation) {
applyCSSPropertyToTargetAndInstances(targetElement(), attributeName(), m_animatedProperty->valueAsString());
} else if (m_animator.isAnimatingCSSProperty()) {
// CSS properties animation code-path.
// Convert the result of the animation to a String and apply it as CSS property on the target & all instances.
applyCSSPropertyToTargetAndInstances(targetElement(), attributeName(), m_animatedProperty->valueAsString());
return;
}
// SVG DOM animVal animation code-path.
// At this point the SVG DOM values are already changed, unlike for CSS.
// We only have to trigger update notifications here.
notifyTargetAndInstancesAboutAnimValChange(targetElement(), attributeName());
}
SVGAnimateElement::~SVGAnimateElement()
{
#if !ENABLE(OILPAN)
if (targetElement())
clearAnimatedType(targetElement());
#endif
}
AnimatedPropertyType SVGAnimateElement::animatedPropertyType()
{
if (!targetElement())
return AnimatedUnknown;
m_animator.reset(targetElement());
return m_animator.type();
}
void SVGAnimateElement::resetAnimatedPropertyType()
{
ASSERT(!m_animatedType);
m_fromType.clear();
m_toType.clear();
m_toAtEndOfDurationType.clear();
m_animator.clear();
m_animatedPropertyType = targetElement() ? determineAnimatedPropertyType(targetElement()) : AnimatedString;
}
void SVGAnimateTransformElement::resetToBaseValue(const String& baseValue)
{
if (!hasValidTarget())
return;
if (baseValue.isEmpty()) {
ExceptionCode ec;
RefPtr<SVGTransformList> list = transformListFor(targetElement());
list->clear(ec);
} else
targetElement()->setAttribute(SVGNames::transformAttr, baseValue);
}
SVGAnimatedTypeAnimator* SVGAnimateElement::ensureAnimator()
{
if (!m_animator)
m_animator = SVGAnimatorFactory::create(this, targetElement(), m_animatedPropertyType);
ASSERT(m_animatedPropertyType == m_animator->type());
return m_animator.get();
}
void SVGAnimationElement::currentValuesForValuesAnimation(float percent, float& effectivePercent, String& from, String& to)
{
unsigned valuesCount = m_values.size();
ASSERT(m_animationValid);
ASSERT(valuesCount >= 1);
if (percent == 1 || valuesCount == 1) {
from = m_values[valuesCount - 1];
to = m_values[valuesCount - 1];
effectivePercent = 1;
return;
}
CalcMode calcMode = this->calcMode();
if (is<SVGAnimateElement>(*this) || is<SVGAnimateColorElement>(*this)) {
ASSERT(targetElement());
AnimatedPropertyType type = downcast<SVGAnimateElementBase>(*this).determineAnimatedPropertyType(*targetElement());
if (type == AnimatedBoolean || type == AnimatedEnumeration || type == AnimatedPreserveAspectRatio || type == AnimatedString)
calcMode = CalcModeDiscrete;
}
if (!m_keyPoints.isEmpty() && calcMode != CalcModePaced)
return currentValuesFromKeyPoints(percent, effectivePercent, from, to);
unsigned keyTimesCount = m_keyTimes.size();
ASSERT(!keyTimesCount || valuesCount == keyTimesCount);
ASSERT(!keyTimesCount || (keyTimesCount > 1 && !m_keyTimes[0]));
unsigned index = calculateKeyTimesIndex(percent);
if (calcMode == CalcModeDiscrete) {
if (!keyTimesCount)
index = static_cast<unsigned>(percent * valuesCount);
from = m_values[index];
to = m_values[index];
effectivePercent = 0;
return;
}
float fromPercent;
float toPercent;
if (keyTimesCount) {
fromPercent = m_keyTimes[index];
toPercent = m_keyTimes[index + 1];
} else {
index = static_cast<unsigned>(floorf(percent * (valuesCount - 1)));
fromPercent = static_cast<float>(index) / (valuesCount - 1);
toPercent = static_cast<float>(index + 1) / (valuesCount - 1);
}
if (index == valuesCount - 1)
--index;
from = m_values[index];
to = m_values[index + 1];
ASSERT_WITH_SECURITY_IMPLICATION(toPercent > fromPercent);
effectivePercent = (percent - fromPercent) / (toPercent - fromPercent);
if (calcMode == CalcModeSpline) {
ASSERT(m_keySplines.size() == m_values.size() - 1);
effectivePercent = calculatePercentForSpline(effectivePercent, index);
}
}
MouseEventWithHitTestResults::MouseEventWithHitTestResults(const BAL::BIMouseEvent& event, const HitTestResult& hitTestResult)
: m_event( static_cast<BAL::BIMouseEvent*>( event.clone() ) )
#else
MouseEventWithHitTestResults::MouseEventWithHitTestResults(const PlatformMouseEvent& event, const HitTestResult& hitTestResult)
: m_event(event)
#endif //__OWB__
, m_hitTestResult(hitTestResult)
{
}
#ifdef __OWB__
MouseEventWithHitTestResults::~MouseEventWithHitTestResults()
{
if( m_event )
delete m_event;
}
#endif
Node* MouseEventWithHitTestResults::targetNode() const
{
Node* node = m_hitTestResult.innerNode();
if (node && node->inDocument())
return node;
Element* element = targetElement(node);
if (element && element->inDocument())
return element;
return node;
}
inline SVGElement* SVGSMILElement::eventBaseFor(const Condition& condition)
{
Element* eventBase = condition.baseID().isEmpty() ? targetElement() : treeScope().getElementById(AtomicString(condition.baseID()));
if (eventBase && eventBase->isSVGElement())
return toSVGElement(eventBase);
return nullptr;
}
void SVGAnimateTransformElement::resetToBaseValue(const String& baseValue)
{
if (!hasValidTarget())
return;
if (targetElement()->hasTagName(SVGNames::linearGradientTag) || targetElement()->hasTagName(SVGNames::radialGradientTag)) {
targetElement()->setAttribute(SVGNames::gradientTransformAttr, baseValue.isEmpty() ? "matrix(1 0 0 1 0 0)" : baseValue);
return;
}
if (baseValue.isEmpty()) {
ExceptionCode ec;
RefPtr<SVGTransformList> list = transformListFor(targetElement());
list->clear(ec);
} else
targetElement()->setAttribute(SVGNames::transformAttr, baseValue);
}
void SVGAnimationElement::checkInvalidCSSAttributeType()
{
bool hasInvalidCSSAttributeType = targetElement() && hasValidAttributeName() && attributeType() == AttributeTypeCSS && !isTargetAttributeCSSProperty(targetElement(), attributeName());
if (hasInvalidCSSAttributeType != m_hasInvalidCSSAttributeType) {
if (hasInvalidCSSAttributeType)
unscheduleIfScheduled();
m_hasInvalidCSSAttributeType = hasInvalidCSSAttributeType;
if (!hasInvalidCSSAttributeType)
schedule();
}
// Clear values that may depend on the previous target.
if (targetElement())
clearAnimatedType();
}
void SVGAnimateMotionElement::resetToBaseValue(const String&)
{
if (!hasValidAttributeType())
return;
AffineTransform* transform = targetElement()->supplementalTransform();
if (!transform)
return;
transform->makeIdentity();
}
void SVGAnimationElement::setAttributeType(const AtomicString& attributeType)
{
static NeverDestroyed<const AtomicString> css("CSS", AtomicString::ConstructFromLiteral);
static NeverDestroyed<const AtomicString> xml("XML", AtomicString::ConstructFromLiteral);
if (attributeType == css)
m_attributeType = AttributeType::CSS;
else if (attributeType == xml)
m_attributeType = AttributeType::XML;
else
m_attributeType = AttributeType::Auto;
checkInvalidCSSAttributeType(targetElement());
}
void SVGAnimationElement::setAttributeType(const AtomicString& attributeType)
{
DEPRECATED_DEFINE_STATIC_LOCAL(const AtomicString, css, ("CSS", AtomicString::ConstructFromLiteral));
DEPRECATED_DEFINE_STATIC_LOCAL(const AtomicString, xml, ("XML", AtomicString::ConstructFromLiteral));
if (attributeType == css)
m_attributeType = AttributeTypeCSS;
else if (attributeType == xml)
m_attributeType = AttributeTypeXML;
else
m_attributeType = AttributeTypeAuto;
checkInvalidCSSAttributeType(targetElement());
}
Node* MouseEventWithHitTestResults::targetNode() const
{
Node* node = m_hitTestResult.innerNode();
if (node && node->inDocument())
return node;
Element* element = targetElement(node);
if (element && element->inDocument())
return element;
return node;
}
void SVGAnimateElement::applyResultsToTarget()
{
ASSERT(m_animatedPropertyType != AnimatedTransformList || hasTagName(SVGNames::animateTransformTag));
ASSERT(m_animatedPropertyType != AnimatedUnknown);
ASSERT(m_animator);
// Early exit if our animated type got destructed by a previous endedActiveInterval().
if (!m_animatedType)
return;
if (m_animatedProperties.isEmpty()) {
// CSS properties animation code-path.
// Convert the result of the animation to a String and apply it as CSS property on the target & all instances.
applyCSSPropertyToTargetAndInstances(targetElement(), attributeName(), m_animatedType->valueAsString());
return;
}
// SVG DOM animVal animation code-path.
// At this point the SVG DOM values are already changed, unlike for CSS.
// We only have to trigger update notifications here.
m_animator->animValDidChange(m_animatedProperties);
notifyTargetAndInstancesAboutAnimValChange(targetElement(), attributeName());
}
void SVGAnimationElement::setTargetAttributeAnimatedValue(const String &value)
{
if (!hasValidTarget()) {
return;
}
SVGElement *target = targetElement();
String attributeName = this->attributeName();
if (!target || attributeName.isEmpty() || value.isNull()) {
return;
}
// We don't want the instance tree to get rebuild. Instances are updated in the loop below.
if (target->isStyled()) {
static_cast<SVGStyledElement *>(target)->setInstanceUpdatesBlocked(true);
}
ExceptionCode ec;
bool isCSS = targetAttributeIsCSS();
if (isCSS) {
// FIXME: This should set the override style, not the inline style.
// Sadly override styles are not yet implemented.
target->style()->setProperty(attributeName, value, "", ec);
} else {
// FIXME: This should set the 'presentation' value, not the actual
// attribute value. Whatever that means in practice.
target->setAttribute(attributeName, value, ec);
}
if (target->isStyled()) {
static_cast<SVGStyledElement *>(target)->setInstanceUpdatesBlocked(false);
}
// If the target element is used in an <use> instance tree, update that as well.
HashSet<SVGElementInstance *> *instances = document()->accessSVGExtensions()->instancesForElement(target);
if (!instances) {
return;
}
HashSet<SVGElementInstance *>::iterator end = instances->end();
for (HashSet<SVGElementInstance *>::iterator it = instances->begin(); it != end; ++it) {
SVGElement *shadowTreeElement = (*it)->shadowTreeElement();
ASSERT(shadowTreeElement);
if (isCSS) {
shadowTreeElement->style()->setProperty(attributeName, value, "", ec);
} else {
shadowTreeElement->setAttribute(attributeName, value, ec);
}
(*it)->correspondingUseElement()->setChanged();
}
}
void SVGSMILElement::buildPendingResource() {
clearResourceAndEventBaseReferences();
if (!isConnected()) {
// Reset the target element if we are no longer in the document.
setTargetElement(nullptr);
return;
}
AtomicString id;
const AtomicString& href = SVGURIReference::legacyHrefString(*this);
Element* target;
if (href.isEmpty())
target = parentNode() && parentNode()->isElementNode()
? toElement(parentNode())
: nullptr;
else
target =
SVGURIReference::targetElementFromIRIString(href, treeScope(), &id);
SVGElement* svgTarget =
target && target->isSVGElement() ? toSVGElement(target) : nullptr;
if (svgTarget && !svgTarget->isConnected())
svgTarget = nullptr;
if (svgTarget != targetElement())
setTargetElement(svgTarget);
if (!svgTarget) {
// Do not register as pending if we are already pending this resource.
if (document().accessSVGExtensions().isElementPendingResource(this, id))
return;
if (!id.isEmpty()) {
document().accessSVGExtensions().addPendingResource(id, this);
ASSERT(hasPendingResources());
}
} else {
// Register us with the target in the dependencies map. Any change of
// hrefElement that leads to relayout/repainting now informs us, so we can
// react to it.
addReferenceTo(svgTarget);
}
connectEventBaseConditions();
}
void SVGSMILElement::buildPendingResource()
{
clearResourceReferences();
if (!inDocument()) {
// Reset the target element if we are no longer in the document.
setTargetElement(0);
return;
}
String id;
String href = getAttribute(XLinkNames::hrefAttr);
Element* target;
if (href.isEmpty())
target = parentNode() && parentNode()->isElementNode() ? toElement(parentNode()) : 0;
else
target = SVGURIReference::targetElementFromIRIString(href, document(), &id);
SVGElement* svgTarget = target && target->isSVGElement() ? toSVGElement(target) : 0;
if (svgTarget && !svgTarget->inDocument())
svgTarget = 0;
if (svgTarget != targetElement())
setTargetElement(svgTarget);
if (!svgTarget) {
// Do not register as pending if we are already pending this resource.
if (document().accessSVGExtensions()->isElementPendingResource(this, id))
return;
if (!id.isEmpty()) {
document().accessSVGExtensions()->addPendingResource(id, this);
ASSERT(hasPendingResources());
}
} else {
// Register us with the target in the dependencies map. Any change of hrefElement
// that leads to relayout/repainting now informs us, so we can react to it.
document().accessSVGExtensions()->addElementReferencingTarget(this, svgTarget);
}
}
nsresult
nsUICommandCollector::GetEventTargets(nsIDOMEvent *event,
nsString &targetId,
nsString &targetAnonId) const
{
// This code deals with both anonymous and explicit (non-anonymous) content.
//
// For explicit content, we just return the id of the event target in
// targetId, and leave targetAnonId empty. If there is no id, then
// we return failure.
//
// For anonymous content, we return the id of the event target (after
// retargeting), in targetId. We return the anonid of the event's
// originalTarget in targetAnonId, so that XBL child elements can be
// distinguished. If there is no anonid, then we return failure.
// Note that the originalTarget is set after text node retargting, but
// before any XBL retargeting.
//
// We assume that if the originalTarget has no id, we're dealing with
// anonymous content (this isn't always true, but it's good enough for what
// this code does).
nsCOMPtr<nsIDOMNSEvent> nsEvent = do_QueryInterface(event);
NS_ENSURE_STATE(nsEvent);
nsCOMPtr<nsIDOMEventTarget> originalTarget;
nsEvent->GetOriginalTarget(getter_AddRefs(originalTarget));
NS_ENSURE_STATE(originalTarget);
nsString origElementId;
nsCOMPtr<nsIDOMElement> origElement(do_QueryInterface(originalTarget));
if (origElement) {
origElement->GetAttribute(NS_LITERAL_STRING("id"), origElementId);
origElement->GetAttribute(NS_LITERAL_STRING("anonid"), targetAnonId);
}
nsCOMPtr<nsIDOMEventTarget> target;
event->GetTarget(getter_AddRefs(target));
NS_ENSURE_STATE(target);
nsCOMPtr<nsIDOMElement> targetElement(do_QueryInterface(target));
if (targetElement) {
targetElement->GetAttribute(NS_LITERAL_STRING("id"), targetId);
}
MS_LOG(("Original Target Id: %s, Original Target Anonid: %s, Target Id: %s",
NS_ConvertUTF16toUTF8(origElementId).get(),
NS_ConvertUTF16toUTF8(targetAnonId).get(),
NS_ConvertUTF16toUTF8(targetId).get()));
if (targetId.IsEmpty()) {
// There's nothing useful to log in this case -- even if we have an anonid,
// it's not possible to determine its position in the document.
MS_LOG(("Warning: skipping logging because of empty target ID"));
return NS_ERROR_FAILURE;
}
if (origElementId.IsEmpty()) {
// We're dealing with anonymous content, so don't continue if we didn't
// find an anonid.
if (targetAnonId.IsEmpty()) {
MS_LOG(("Warning: skipping logging because of empty anonid"));
return NS_ERROR_FAILURE;
}
} else {
// We're dealing with normal explicit content, so don't return an anonid.
targetAnonId.SetLength(0);
}
return NS_OK;
}
bool SVGAnimationElement::hasValidTarget() const
{
return targetElement();
}
void SVGAnimationElement::setAttributeName(const QualifiedName& attributeName)
{
SVGSMILElement::setAttributeName(attributeName);
checkInvalidCSSAttributeType(targetElement());
}
SVGAnimateElement::~SVGAnimateElement()
{
if (targetElement())
clearAnimatedType(targetElement());
}
SVGAnimatedTypeAnimator* SVGAnimateElement::ensureAnimator()
{
if (!m_animator)
m_animator = SVGAnimatedTypeAnimator::create(this, targetElement());
return m_animator.get();
}
