svganimatedproperty.h

来自「linux下开源浏览器WebKit的源码,市面上的很多商用浏览器都是移植自Web」· C头文件 代码 · 共 461 行 · 第 1/2 页

    template<typename OwnerTypeArg, typename AnimatedTypeArg, const char* TagName, const char* PropertyName>
    template<typename T1, typename T2>
    SVGAnimatedProperty<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName>::SVGAnimatedProperty(const OwnerType* owner,
                                                                                                   const QualifiedName& attributeName,
                                                                                                   const T1& arg1,
                                                                                                   const T2& arg2)
        : m_ownerType(owner)
        , m_attributeName(attributeName)
        , m_attributeIdentifier(attributeName.localName())
        , m_value(arg1, arg2)
    {
        ASSERT(m_ownerType);
    }

    template<typename OwnerTypeArg, typename AnimatedTypeArg, const char* TagName, const char* PropertyName>
    template<typename T1, typename T2>
    SVGAnimatedProperty<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName>::SVGAnimatedProperty(const OwnerType* owner,
                                                                                                   const QualifiedName& attributeName,
                                                                                                   const AtomicString& attributeIdentifier,
                                                                                                   const T1& arg1,
                                                                                                   const T2& arg2)
        : m_ownerType(owner)
        , m_attributeName(attributeName)
        , m_attributeIdentifier(attributeIdentifier)
        , m_value(arg1, arg2)
    {
        ASSERT(m_ownerType);
    }

    template<typename OwnerTypeArg, typename AnimatedTypeArg, const char* TagName, const char* PropertyName>
    template<typename T1, typename T2, typename T3>
    SVGAnimatedProperty<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName>::SVGAnimatedProperty(const OwnerType* owner,
                                                                                                   const QualifiedName& attributeName,
                                                                                                   const T1& arg1,
                                                                                                   const T2& arg2,
                                                                                                   const T3& arg3)
        : m_ownerType(owner)
        , m_attributeName(attributeName)
        , m_attributeIdentifier(attributeName.localName())
        , m_value(arg1, arg2, arg3)
    {
        ASSERT(m_ownerType);
    }

    template<typename OwnerTypeArg, typename AnimatedTypeArg, const char* TagName, const char* PropertyName>
    template<typename T1, typename T2, typename T3>
    SVGAnimatedProperty<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName>::SVGAnimatedProperty(const OwnerType* owner,
                                                                                                   const QualifiedName& attributeName,
                                                                                                   const AtomicString& attributeIdentifier,
                                                                                                   const T1& arg1,
                                                                                                   const T2& arg2,
                                                                                                   const T3& arg3)
        : m_ownerType(owner)
        , m_attributeName(attributeName)
        , m_attributeIdentifier(attributeIdentifier)
        , m_value(arg1, arg2, arg3)
    {
        ASSERT(m_ownerType);
    }

    template<typename OwnerTypeArg, typename AnimatedTypeArg, const char* TagName, const char* PropertyName>
    typename SVGAnimatedProperty<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName>::DecoratedType
    SVGAnimatedProperty<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName>::value() const
    {
        return m_value;
    }

    template<typename OwnerTypeArg, typename AnimatedTypeArg, const char* TagName, const char* PropertyName>
    void SVGAnimatedProperty<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName>::setValue(typename SVGAnimatedProperty::DecoratedType newValue)
    {
        m_value = newValue;
        ownerElement()->setSynchronizedSVGAttributes(false);
    }

    template<typename OwnerTypeArg, typename AnimatedTypeArg, const char* TagName, const char* PropertyName>
    typename SVGAnimatedProperty<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName>::DecoratedType
    SVGAnimatedProperty<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName>::baseValue() const
    {
        const OwnerElement* ownerElement = this->ownerElement();
        SVGDocumentExtensions* extensions = ownerElement->accessDocumentSVGExtensions();
        if (extensions && extensions->hasBaseValue<DecoratedType>(ownerElement, m_attributeIdentifier))
            return extensions->baseValue<DecoratedType>(ownerElement, m_attributeIdentifier);

        return m_value;
    }

    template<typename OwnerTypeArg, typename AnimatedTypeArg, const char* TagName, const char* PropertyName>
    void SVGAnimatedProperty<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName>::setBaseValue(typename SVGAnimatedProperty::DecoratedType newValue)
    {
        const OwnerElement* ownerElement = this->ownerElement();
        SVGDocumentExtensions* extensions = ownerElement->accessDocumentSVGExtensions();
        if (extensions && extensions->hasBaseValue<DecoratedType>(ownerElement, m_attributeIdentifier)) {
            extensions->setBaseValue<DecoratedType>(ownerElement, m_attributeIdentifier, newValue);
            return;
        }

        // Only update stored property, if not animating
        m_value = newValue;
        ownerElement->setSynchronizedSVGAttributes(false);
    }

    template<typename OwnerTypeArg, typename AnimatedTypeArg, const char* TagName, const char* PropertyName>
    PassRefPtr<typename SVGAnimatedProperty<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName>::TearOff>
    SVGAnimatedProperty<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName>::animatedTearOff() const
    {
        return lookupOrCreateWrapper<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName, TearOff, OwnerElement>(*this, ownerElement(), m_attributeName, m_attributeIdentifier);
    }

    template<typename OwnerTypeArg, typename AnimatedTypeArg, const char* TagName, const char* PropertyName>
    void SVGAnimatedProperty<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName>::synchronize() const
    {
        if (!m_value.needsSynchronization()) 
            return; 

        synchronizeProperty<OwnerElement, DecoratedType>(ownerElement(), m_attributeName, baseValue());
        m_value.setSynchronized(); 
    }

    template<typename OwnerTypeArg, typename AnimatedTypeArg, const char* TagName, const char* PropertyName>
    void SVGAnimatedProperty<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName>::startAnimation() const
    {
        const OwnerElement* ownerElement = this->ownerElement();
        SVGDocumentExtensions* extensions = ownerElement->accessDocumentSVGExtensions();
        if (extensions) {
            ASSERT(!extensions->hasBaseValue<DecoratedType>(ownerElement, m_attributeIdentifier));
            extensions->setBaseValue<DecoratedType>(ownerElement, m_attributeIdentifier, m_value);
        }
    }
    
    template<typename OwnerTypeArg, typename AnimatedTypeArg, const char* TagName, const char* PropertyName>
    void SVGAnimatedProperty<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName>::stopAnimation()
    {
        const OwnerElement* ownerElement = this->ownerElement();
        SVGDocumentExtensions* extensions = ownerElement->accessDocumentSVGExtensions();
        if (extensions) {
            ASSERT(extensions->hasBaseValue<DecoratedType>(ownerElement, m_attributeIdentifier));
            setValue(extensions->baseValue<DecoratedType>(ownerElement, m_attributeIdentifier));
            extensions->removeBaseValue<AnimatedType>(ownerElement, m_attributeIdentifier);
        }
    }

    template<typename OwnerTypeArg, typename AnimatedTypeArg, const char* TagName, const char* PropertyName>
    const typename SVGAnimatedProperty<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName>::OwnerElement*
    SVGAnimatedProperty<OwnerTypeArg, AnimatedTypeArg, TagName, PropertyName>::ownerElement() const
    {
        return OwnerElementForType::ownerElement(m_ownerType);
    }

    // GetOwnerElementForType implementation
    template<typename OwnerType>
    struct GetOwnerElementForType<OwnerType, true> : Noncopyable {
        typedef OwnerType OwnerElement;

        static const OwnerElement* ownerElement(const OwnerType* type)
        {
            return type;
        }
    };

    template<typename OwnerType>
    struct GetOwnerElementForType<OwnerType, false> : Noncopyable {    
        typedef SVGElement OwnerElement;

        static const OwnerElement* ownerElement(const OwnerType* type)
        {
            const OwnerElement* context = type->contextElement();
            ASSERT(context);
            return context;
        }
    };

    // IsDerivedFromSVGElement implementation
    template<typename OwnerType>
    struct IsDerivedFromSVGElement : Noncopyable {
        static const bool value = true;
    };

    class SVGExternalResourcesRequired;
    template<>
    struct IsDerivedFromSVGElement<SVGExternalResourcesRequired> : Noncopyable {
        static const bool value = false;
    };

    class SVGFitToViewBox;
    template<>
    struct IsDerivedFromSVGElement<SVGFitToViewBox> : Noncopyable {
        static const bool value = false;
    };

    class SVGURIReference;
    template<>
    struct IsDerivedFromSVGElement<SVGURIReference> : Noncopyable {
        static const bool value = false;
    };

    // Central function handling the main SVG<->XML synchronization part.
    template<typename OwnerElement, typename DecoratedType>
    void synchronizeProperty(const OwnerElement* ownerElement, const QualifiedName& attributeName, DecoratedType baseValue)
    {
        AtomicString value(SVGAnimatedTypeValue<DecoratedType>::toString(baseValue));

        NamedAttrMap* namedAttrMap = ownerElement->attributes(false); 
        Attribute* old = namedAttrMap->getAttributeItem(attributeName);
        if (old && value.isNull()) 
            namedAttrMap->removeAttribute(old->name()); 
        else if (!old && !value.isNull()) 
            namedAttrMap->addAttribute(const_cast<OwnerElement*>(ownerElement)->createAttribute(QualifiedName(nullAtom, attributeName.localName(), nullAtom), value)); 
        else if (old && !value.isNull()) 
            old->setValue(value); 
    }

    // Helper macro used to register animated properties within SVG* classes
    #define ANIMATED_PROPERTY_DECLARATIONS(OwnerType, ElementTag, AttributeTag, AnimatedType, UpperProperty, LowerProperty) \
    private: \
        typedef SVGAnimatedProperty<OwnerType, AnimatedType, ElementTag, AttributeTag> SVGAnimatedProperty##UpperProperty; \
        typedef SVGAnimatedTypeValue<AnimatedType>::DecoratedType DecoratedTypeFor##UpperProperty; \
        SVGAnimatedProperty##UpperProperty m_##LowerProperty; \
    public: \
        DecoratedTypeFor##UpperProperty LowerProperty() const { return m_##LowerProperty.value(); } \
        void set##UpperProperty(DecoratedTypeFor##UpperProperty type) { m_##LowerProperty.setValue(type); } \
        DecoratedTypeFor##UpperProperty LowerProperty##BaseValue() const { return m_##LowerProperty.baseValue(); } \
        void set##UpperProperty##BaseValue(DecoratedTypeFor##UpperProperty type) { m_##LowerProperty.setBaseValue(type); } \
        PassRefPtr<SVGAnimatedProperty##UpperProperty::TearOff> LowerProperty##Animated() const { return m_##LowerProperty.animatedTearOff(); } \
        void synchronize##UpperProperty() const { m_##LowerProperty.synchronize(); }

};

#endif
#endif