File indexing completed on 2024-04-28 11:39:10

 /*
     Copyright (C) 2006 Apple Computer, Inc.
                   2006 Nikolas Zimmermann <zimmermann@kde.org>
 
     This file is part of the WebKit project
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     Boston, MA 02110-1301, USA.
 */
 
 #ifndef SVGDocumentExtensions_h
 #define SVGDocumentExtensions_h
 
 #if ENABLE(SVG)
 
 #include <memory>
 #include <wtf/Forward.h>
 #include <wtf/HashSet.h>
 #include <wtf/HashMap.h>
 
 #include "FloatRect.h"
 #include "StringHash.h"
 //#include "StringImpl.h"
 #include "AtomicString.h"
 #include "xml/Document.h"
 
 namespace DOM
 {
 class EventListener;
 }
 
 namespace WebCore
 {
 
 //class AtomicString;
 //class Document;
 //class EventListener;
 //class Node;
 //class String;
 class SVGElement;
 class SVGElementInstance;
 class SVGStyledElement;
 class SVGSVGElement;
 class TimeScheduler;
 
 class DOMStringHash
 {
 public:
     static unsigned hash(DOMString key)
     {
         return qHash(key.implementation());
     }
     static bool equal(DOMString a, DOMString b)
     {
         return a == b;
     }
     static const bool safeToCompareToEmptyOrDeleted = false;
 };
 
 class SVGDocumentExtensions
 {
 public:
     SVGDocumentExtensions(Document *);
     ~SVGDocumentExtensions();
 
     DOM::EventListener *createSVGEventListener(const DOMString &functionName, const DOMString &code, DOM::NodeImpl *);
 
     void addTimeContainer(SVGSVGElement *);
     void removeTimeContainer(SVGSVGElement *);
 
     void startAnimations();
     void pauseAnimations();
     void unpauseAnimations();
 
     void reportWarning(const String &);
     void reportError(const String &);
 
 private:
     Document *m_doc; // weak reference
     HashSet<SVGSVGElement *> m_timeContainers; // For SVG 1.2 support this will need to be made more general.
     //HashMap<String, HashSet<SVGStyledElement*>*, DOMStringHash> m_pendingResources;
     HashMap<SVGElement *, HashSet<SVGElementInstance *>*> m_elementInstances;
 
     SVGDocumentExtensions(const SVGDocumentExtensions &);
     SVGDocumentExtensions &operator=(const SVGDocumentExtensions &);
 
     template<typename ValueType>
     HashMap<const SVGElement *, HashMap<StringImpl *, ValueType>*> *baseValueMap() const
     {
         static HashMap<const SVGElement *, HashMap<StringImpl *, ValueType>*> *s_baseValueMap = new HashMap<const SVGElement *, HashMap<StringImpl *, ValueType>*>();
         return s_baseValueMap;
     }
 
 public:
     // This HashMap contains a list of pending resources. Pending resources, are such
     // which are referenced by any object in the SVG document, but do NOT exist yet.
     // For instance, dynamically build gradients / patterns / clippers...
     void addPendingResource(const AtomicString &id, SVGStyledElement *);
     bool isPendingResource(const AtomicString &id) const;
     std::unique_ptr<HashSet<SVGStyledElement *> > removePendingResource(const AtomicString &id);
 
     // This HashMap maps elements to their instances, when they are used by <use> elements.
     // This is needed to synchronize the original element with the internally cloned one.
     void mapInstanceToElement(SVGElementInstance *, SVGElement *);
     void removeInstanceMapping(SVGElementInstance *, SVGElement *);
     HashSet<SVGElementInstance *> *instancesForElement(SVGElement *) const;
 
     // Used by the ANIMATED_PROPERTY_* macros
     template<typename ValueType>
     ValueType baseValue(const SVGElement *element, const AtomicString &propertyName) const
     {
         HashMap<StringImpl *, ValueType> *propertyMap = baseValueMap<ValueType>()->get(element);
         if (propertyMap) {
             return propertyMap->get(propertyName.impl());
         }
 
         return ValueType();
     }
 
     template<typename ValueType>
     void setBaseValue(const SVGElement *element, const AtomicString &propertyName, ValueType newValue)
     {
         HashMap<StringImpl *, ValueType> *propertyMap = baseValueMap<ValueType>()->get(element);
         if (!propertyMap) {
             propertyMap = new HashMap<StringImpl *, ValueType>();
             baseValueMap<ValueType>()->set(element, propertyMap);
         }
 
         propertyMap->set(propertyName.impl(), newValue);
     }
 
     template<typename ValueType>
     void removeBaseValue(const SVGElement *element, const AtomicString &propertyName)
     {
         HashMap<StringImpl *, ValueType> *propertyMap = baseValueMap<ValueType>()->get(element);
         if (!propertyMap) {
             return;
         }
 
         propertyMap->remove(propertyName.impl());
     }
 
     template<typename ValueType>
     bool hasBaseValue(const SVGElement *element, const AtomicString &propertyName) const
     {
         HashMap<StringImpl *, ValueType> *propertyMap = baseValueMap<ValueType>()->get(element);
         if (propertyMap) {
             return propertyMap->contains(propertyName.impl());
         }
 
         return false;
     }
 };
 
 // Special handling for WebCore::String
 template<>
 inline String SVGDocumentExtensions::baseValue<String>(const SVGElement *element, const AtomicString &propertyName) const
 {
     HashMap<StringImpl *, String> *propertyMap = baseValueMap<String>()->get(element);
     if (propertyMap) {
         return propertyMap->get(propertyName.impl());
     }
 
     return String();
 }
 
 // Special handling for WebCore::FloatRect
 template<>
 inline FloatRect SVGDocumentExtensions::baseValue<FloatRect>(const SVGElement *element, const AtomicString &propertyName) const
 {
     HashMap<StringImpl *, FloatRect> *propertyMap = baseValueMap<FloatRect>()->get(element);
     if (propertyMap) {
         return propertyMap->get(propertyName.impl());
     }
 
     return FloatRect();
 }
 
 // Special handling for booleans
 template<>
 inline bool SVGDocumentExtensions::baseValue<bool>(const SVGElement *element, const AtomicString &propertyName) const
 {
     HashMap<StringImpl *, bool> *propertyMap = baseValueMap<bool>()->get(element);
     if (propertyMap) {
         return propertyMap->get(propertyName.impl());
     }
 
     return false;
 }
 
 // Special handling for doubles
 template<>
 inline double SVGDocumentExtensions::baseValue<double>(const SVGElement *element, const AtomicString &propertyName) const
 {
     HashMap<StringImpl *, double> *propertyMap = baseValueMap<double>()->get(element);
     if (propertyMap) {
         return propertyMap->get(propertyName.impl());
     }
 
     return 0.0;
 }
 
 }
 
 #endif // ENABLE(SVG)
 
 #endif