自学教程：C++ toSVGElement函数代码示例

sk_sp<SkImageFilter> FEImage::createImageFilterForLayoutObject(const LayoutObject& layoutObject){    FloatRect dstRect = filterPrimitiveSubregion();    AffineTransform transform;    SVGElement* contextNode = toSVGElement(layoutObject.node());    if (contextNode->hasRelativeLengths()) {        SVGLengthContext lengthContext(contextNode);        FloatSize viewportSize;        // If we're referencing an element with percentage units, eg. <rect with="30%"> those values were resolved against the viewport.        // Build up a transformation that maps from the viewport space to the filter primitive subregion.        if (lengthContext.determineViewport(viewportSize))            transform = makeMapBetweenRects(FloatRect(FloatPoint(), viewportSize), dstRect);    } else {        transform.translate(dstRect.x(), dstRect.y());    }    SkPictureBuilder filterPicture(dstRect);    {        TransformRecorder transformRecorder(filterPicture.context(), layoutObject, transform);        SVGPaintContext::paintSubtree(filterPicture.context(), &layoutObject);    }    return SkPictureImageFilter::Make(toSkSp(filterPicture.endRecording()), dstRect);}

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 KeyframeEffect::applyEffects(){    ASSERT(isInEffect());    ASSERT(animation());    if (!m_target || !m_model)        return;    // Cancel composited animation of transform if a motion path has been introduced on the element.    if (m_target->computedStyle()        && m_target->computedStyle()->hasMotionPath()        && animation()->hasActiveAnimationsOnCompositor()        && animation()->affects(*m_target, CSSPropertyTransform)) {        animation()->cancelAnimationOnCompositor();    }    double iteration = currentIteration();    ASSERT(iteration >= 0);    OwnPtrWillBeRawPtr<WillBeHeapVector<RefPtrWillBeMember<Interpolation>>> interpolations = m_sampledEffect ? m_sampledEffect->mutableInterpolations() : nullptr;    // FIXME: Handle iteration values which overflow int.    m_model->sample(static_cast<int>(iteration), timeFraction(), iterationDuration(), interpolations);    if (m_sampledEffect) {        m_sampledEffect->setInterpolations(interpolations.release());    } else if (interpolations && !interpolations->isEmpty()) {        OwnPtrWillBeRawPtr<SampledEffect> sampledEffect = SampledEffect::create(this, interpolations.release());        m_sampledEffect = sampledEffect.get();        ensureAnimationStack(m_target).add(sampledEffect.release());    } else {        return;    }    m_target->setNeedsAnimationStyleRecalc();    if (m_target->isSVGElement())        m_sampledEffect->applySVGUpdate(toSVGElement(*m_target));}

AffineTransform SVGGraphicsElement::computeCTM(SVGElement::CTMScope mode,    SVGGraphicsElement::StyleUpdateStrategy styleUpdateStrategy, const SVGGraphicsElement* ancestor) const{    if (styleUpdateStrategy == AllowStyleUpdate)        document().updateStyleAndLayoutIgnorePendingStylesheets();    AffineTransform ctm;    bool done = false;    for (const Element* currentElement = this; currentElement && !done;        currentElement = currentElement->parentOrShadowHostElement()) {        if (!currentElement->isSVGElement())            break;        ctm = toSVGElement(currentElement)->localCoordinateSpaceTransform(mode).multiply(ctm);        switch (mode) {        case NearestViewportScope:            // Stop at the nearest viewport ancestor.            done = currentElement != this && isViewportElement(*currentElement);            break;        case AncestorScope:            // Stop at the designated ancestor.            done = currentElement == ancestor;            break;        default:            ASSERT(mode == ScreenScope);            break;        }    }    return ctm;}

void SVGRenderSupport::applyStrokeStyleToContext(GraphicsContext* context, const RenderStyle* style, const RenderObject* object){    ASSERT(context);    ASSERT(style);    ASSERT(object);    ASSERT(object->node());    ASSERT(object->node()->isSVGElement());    const SVGRenderStyle* svgStyle = style->svgStyle();    ASSERT(svgStyle);    SVGLengthContext lengthContext(toSVGElement(object->node()));    context->setStrokeThickness(svgStyle->strokeWidth()->value(lengthContext));    context->setLineCap(svgStyle->capStyle());    context->setLineJoin(svgStyle->joinStyle());    context->setMiterLimit(svgStyle->strokeMiterLimit());    RefPtr<SVGLengthList> dashes = svgStyle->strokeDashArray();    if (dashes->isEmpty())        return;    DashArray dashArray;    SVGLengthList::ConstIterator it = dashes->begin();    SVGLengthList::ConstIterator itEnd = dashes->end();    for (; it != itEnd; ++it)        dashArray.append(it->value(lengthContext));    context->setLineDash(dashArray, svgStyle->strokeDashOffset()->value(lengthContext));}

bool CSSCursorImageValue::updateIfSVGCursorIsUsed(Element* element){    if (!element || !element->isSVGElement())        return false;    if (!isSVGCursor())        return false;    String url = toCSSImageValue(m_imageValue.get())->url();    if (SVGCursorElement* cursorElement = resourceReferencedByCursorElement(url, element->treeScope())) {        // FIXME: This will override hot spot specified in CSS, which is probably incorrect.        SVGLengthContext lengthContext(0);        m_hotSpotSpecified = true;        float x = roundf(cursorElement->x()->currentValue()->value(lengthContext));        m_hotSpot.setX(static_cast<int>(x));        float y = roundf(cursorElement->y()->currentValue()->value(lengthContext));        m_hotSpot.setY(static_cast<int>(y));        if (cachedImageURL() != element->document().completeURL(cursorElement->href()->currentValue()->value()))            clearImageResource();        SVGElement* svgElement = toSVGElement(element);#if !ENABLE(OILPAN)        m_referencedElements.add(svgElement);#endif        svgElement->setCursorImageValue(this);        cursorElement->addClient(svgElement);        return true;    }    return false;}

static PassRefPtrWillBeRawPtr<Node> cloneNodeAndAssociate(Node& toClone){    RefPtrWillBeRawPtr<Node> clone = toClone.cloneNode(false);    if (!clone->isSVGElement())        return clone.release();    SVGElement& svgElement = toSVGElement(toClone);    ASSERT(!svgElement.correspondingElement());    toSVGElement(clone.get())->setCorrespondingElement(&svgElement);    if (EventTargetData* data = toClone.eventTargetData())        data->eventListenerMap.copyEventListenersNotCreatedFromMarkupToTarget(clone.get());    TrackExceptionState exceptionState;    for (RefPtrWillBeRawPtr<Node> node = toClone.firstChild(); node && !exceptionState.hadException(); node = node->nextSibling())        clone->appendChild(cloneNodeAndAssociate(*node), exceptionState);    return clone.release();}

RenderObject* SVGAElement::createRenderer(RenderStyle*){    if (parentNode() && parentNode()->isSVGElement() && toSVGElement(parentNode())->isTextContent())        return new RenderSVGInline(this);    return new RenderSVGTransformableContainer(this);}

PassRefPtr<SkImageFilter> FEImage::createImageFilterForRenderer(RenderObject* renderer, SkiaImageFilterBuilder* builder){    FloatRect dstRect = filterPrimitiveSubregion();    AffineTransform transform;    SVGElement* contextNode = toSVGElement(renderer->node());    if (contextNode->hasRelativeLengths()) {        SVGLengthContext lengthContext(contextNode);        FloatSize viewportSize;        // If we're referencing an element with percentage units, eg. <rect with="30%"> those values were resolved against the viewport.        // Build up a transformation that maps from the viewport space to the filter primitive subregion.        if (lengthContext.determineViewport(viewportSize))            transform = makeMapBetweenRects(FloatRect(FloatPoint(), viewportSize), dstRect);    } else {        transform.translate(dstRect.x(), dstRect.y());    }    GraphicsContext* context = builder->context();    if (!context)        return adoptRef(SkBitmapSource::Create(SkBitmap()));    AffineTransform contentTransformation;    context->save();    context->beginRecording(FloatRect(FloatPoint(), dstRect.size()));    context->concatCTM(transform);    SVGRenderingContext::renderSubtree(context, renderer, contentTransformation);    RefPtr<DisplayList> displayList = context->endRecording();    context->restore();    RefPtr<SkImageFilter> result = adoptRef(SkPictureImageFilter::Create(displayList->picture(), dstRect));    return result.release();}

RenderPtr<RenderElement> SVGAElement::createElementRenderer(PassRef<RenderStyle> style){    if (parentNode() && parentNode()->isSVGElement() && toSVGElement(parentNode())->isTextContent())        return createRenderer<RenderSVGInline>(*this, WTF::move(style));    return createRenderer<RenderSVGTransformableContainer>(*this, WTF::move(style));}

void SVGMPathElement::buildPendingResource(){    clearResourceReferences();    if (!inDocument())        return;    String id;    Element* target = SVGURIReference::targetElementFromIRIString(href(), document(), &id);    if (!target) {        // Do not register as pending if we are already pending this resource.        if (document().accessSVGExtensions()->isPendingResource(this, id))            return;        if (!id.isEmpty()) {            document().accessSVGExtensions()->addPendingResource(id, this);            ASSERT(hasPendingResources());        }    } else if (target->isSVGElement()) {        // 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, toSVGElement(target));    }    targetPathChanged();}

void KeyframeEffect::applyEffects(){    ASSERT(isInEffect());    ASSERT(animation());    if (!m_target || !m_model)        return;    if (hasIncompatibleStyle())        animation()->cancelAnimationOnCompositor();    double iteration = currentIteration();    ASSERT(iteration >= 0);    bool changed = false;    if (m_sampledEffect) {        changed = m_model->sample(clampTo<int>(iteration, 0), timeFraction(), iterationDuration(), m_sampledEffect->mutableInterpolations());    } else {        Vector<RefPtr<Interpolation>> interpolations;        m_model->sample(clampTo<int>(iteration, 0), timeFraction(), iterationDuration(), interpolations);        if (!interpolations.isEmpty()) {            SampledEffect* sampledEffect = SampledEffect::create(this);            sampledEffect->mutableInterpolations().swap(interpolations);            m_sampledEffect = sampledEffect;            ensureAnimationStack(m_target).add(sampledEffect);            changed = true;        } else {            return;        }    }    if (changed) {        m_target->setNeedsAnimationStyleRecalc();        if (RuntimeEnabledFeatures::webAnimationsSVGEnabled() && m_target->isSVGElement())            toSVGElement(*m_target).setWebAnimationsPending();    }}

void SVGRenderSupport::applyStrokeStyleToContext(GraphicsContext* context, const RenderStyle& style, const RenderElement& renderer){    ASSERT(context);    ASSERT(renderer.element());    ASSERT(renderer.element()->isSVGElement());    const SVGRenderStyle& svgStyle = style.svgStyle();    SVGLengthContext lengthContext(toSVGElement(renderer.element()));    context->setStrokeThickness(svgStyle.strokeWidth().value(lengthContext));    context->setLineCap(svgStyle.capStyle());    context->setLineJoin(svgStyle.joinStyle());    if (svgStyle.joinStyle() == MiterJoin)        context->setMiterLimit(svgStyle.strokeMiterLimit());    const Vector<SVGLength>& dashes = svgStyle.strokeDashArray();    if (dashes.isEmpty())        context->setStrokeStyle(SolidStroke);    else {        DashArray dashArray;        dashArray.reserveInitialCapacity(dashes.size());        for (unsigned i = 0, size = dashes.size(); i < size; ++i)            dashArray.uncheckedAppend(dashes[i].value(lengthContext));        context->setLineDash(dashArray, svgStyle.strokeDashOffset().value(lengthContext));    }}

PassRefPtr<SVGFilterBuilder> RenderSVGResourceFilter::buildPrimitives(SVGFilter* filter){    SVGFilterElement* filterElement = toSVGFilterElement(node());    FloatRect targetBoundingBox = filter->targetBoundingBox();    // Add effects to the builder    RefPtr<SVGFilterBuilder> builder = SVGFilterBuilder::create(SourceGraphic::create(filter), SourceAlpha::create(filter));    for (Node* node = filterElement->firstChild(); node; node = node->nextSibling()) {        if (!node->isSVGElement())            continue;        SVGElement* element = toSVGElement(node);        if (!element->isFilterEffect())            continue;        SVGFilterPrimitiveStandardAttributes* effectElement = static_cast<SVGFilterPrimitiveStandardAttributes*>(element);        RefPtr<FilterEffect> effect = effectElement->build(builder.get(), filter);        if (!effect) {            builder->clearEffects();            return 0;        }        builder->appendEffectToEffectReferences(effect, effectElement->renderer());        effectElement->setStandardAttributes(effect.get());        effect->setEffectBoundaries(SVGLengthContext::resolveRectangle<SVGFilterPrimitiveStandardAttributes>(effectElement, filterElement->primitiveUnits(), targetBoundingBox));        effect->setOperatingColorSpace(            effectElement->renderer()->style()->svgStyle()->colorInterpolationFilters() == CI_LINEARRGB ? ColorSpaceLinearRGB : ColorSpaceDeviceRGB);        builder->add(effectElement->result(), effect);    }    return builder.release();}

void SVGUseElement::buildPendingResource(){    if (inUseShadowTree())        return;    clearShadowTree();    cancelShadowTreeRecreation();    if (!referencedScope() || !inDocument())        return;    AtomicString id;    Element* target = SVGURIReference::targetElementFromIRIString(hrefString(), treeScope(), &id, externalDocument());    if (!target || !target->inDocument()) {        // If we can't find the target of an external element, just give up.        // We can't observe if the target somewhen enters the external document, nor should we do it.        if (externalDocument())            return;        if (id.isEmpty())            return;        referencedScope()->document().accessSVGExtensions().addPendingResource(id, this);        ASSERT(hasPendingResources());        return;    }    if (target->isSVGElement()) {        buildShadowAndInstanceTree(toSVGElement(target));        invalidateDependentShadowTrees();    }    ASSERT(!m_needsShadowTreeRecreation);}

static inline const AtomicString& linkAttribute(const Element& element){    DCHECK(element.isLink());    if (element.isHTMLElement())        return element.fastGetAttribute(HTMLNames::hrefAttr);    DCHECK(element.isSVGElement());    return SVGURIReference::legacyHrefString(toSVGElement(element));}

static void writeStyle(TextStream& ts, const RenderObject& object){    const RenderStyle* style = object.style();    const SVGRenderStyle* svgStyle = style->svgStyle();    if (!object.localTransform().isIdentity())        writeNameValuePair(ts, "transform", object.localTransform());    writeIfNotDefault(ts, "image rendering", style->imageRendering(), RenderStyle::initialImageRendering());    writeIfNotDefault(ts, "opacity", style->opacity(), RenderStyle::initialOpacity());    if (object.isSVGShape()) {        const RenderSVGShape& shape = static_cast<const RenderSVGShape&>(object);        ASSERT(shape.node());        ASSERT(shape.node()->isSVGElement());        Color fallbackColor;        if (RenderSVGResource* strokePaintingResource = RenderSVGResource::strokePaintingResource(const_cast<RenderSVGShape*>(&shape), shape.style(), fallbackColor)) {            TextStreamSeparator s(" ");            ts << " [stroke={" << s;            writeSVGPaintingResource(ts, strokePaintingResource);            SVGLengthContext lengthContext(toSVGElement(shape.node()));            double dashOffset = svgStyle->strokeDashOffset().value(lengthContext);            double strokeWidth = svgStyle->strokeWidth().value(lengthContext);            const Vector<SVGLength>& dashes = svgStyle->strokeDashArray();            DashArray dashArray;            const Vector<SVGLength>::const_iterator end = dashes.end();            for (Vector<SVGLength>::const_iterator it = dashes.begin(); it != end; ++it)                dashArray.append((*it).value(lengthContext));            writeIfNotDefault(ts, "opacity", svgStyle->strokeOpacity(), 1.0f);            writeIfNotDefault(ts, "stroke width", strokeWidth, 1.0);            writeIfNotDefault(ts, "miter limit", svgStyle->strokeMiterLimit(), 4.0f);            writeIfNotDefault(ts, "line cap", svgStyle->capStyle(), ButtCap);            writeIfNotDefault(ts, "line join", svgStyle->joinStyle(), MiterJoin);            writeIfNotDefault(ts, "dash offset", dashOffset, 0.0);            if (!dashArray.isEmpty())                writeNameValuePair(ts, "dash array", dashArray);            ts << "}]";        }        if (RenderSVGResource* fillPaintingResource = RenderSVGResource::fillPaintingResource(const_cast<RenderSVGShape*>(&shape), shape.style(), fallbackColor)) {            TextStreamSeparator s(" ");            ts << " [fill={" << s;            writeSVGPaintingResource(ts, fillPaintingResource);            writeIfNotDefault(ts, "opacity", svgStyle->fillOpacity(), 1.0f);            writeIfNotDefault(ts, "fill rule", svgStyle->fillRule(), RULE_NONZERO);            ts << "}]";        }        writeIfNotDefault(ts, "clip rule", svgStyle->clipRule(), RULE_NONZERO);    }    writeIfNotEmpty(ts, "start marker", svgStyle->markerStartResource());    writeIfNotEmpty(ts, "middle marker", svgStyle->markerMidResource());    writeIfNotEmpty(ts, "end marker", svgStyle->markerEndResource());}

void writeSVGGradientStop(TextStream& ts, const RenderSVGGradientStop& stop, int indent){    writeStandardPrefix(ts, stop, indent);    SVGStopElement* stopElement = toSVGStopElement(toSVGElement(stop.element()));    ASSERT(stopElement);    ts << " [offset=" << stopElement->offset() << "] [color=" << stopElement->stopColorIncludingOpacity() << "]/n";}

SVGElement* SVGGraphicsElement::nearestViewportElement() const{    for (Element* current = parentOrShadowHostElement(); current; current = current->parentOrShadowHostElement()) {        if (isViewportElement(*current))            return toSVGElement(current);    }    return nullptr;}

static bool hasValidPredecessor(const Node* node){    ASSERT(node);    for (node = node->previousSibling(); node; node = node->previousSibling()) {        if (node->isSVGElement() && toSVGElement(node)->isValid())            return true;    }    return false;}

SVGElement* SVGViewSpec::viewTarget() const{    if (!m_contextElement)        return 0;    Element* element = m_contextElement->treeScope().getElementById(m_viewTargetString);    if (!element || !element->isSVGElement())        return 0;    return toSVGElement(element);}

void KeyframeEffectReadOnly::attach(Animation* animation) {  if (m_target) {    m_target->ensureElementAnimations().animations().add(animation);    m_target->setNeedsAnimationStyleRecalc();    if (RuntimeEnabledFeatures::webAnimationsSVGEnabled() &&        m_target->isSVGElement())      toSVGElement(m_target)->setWebAnimationsPending();  }  AnimationEffectReadOnly::attach(animation);}