Remove SVGLocatable and SVGTransformable

Source/core/svg/SVGGraphicsElement.cpp

 /*
  * Copyright (C) 2004, 2005, 2008 Nikolas Zimmermann <zimmermann@kde.org>
  * Copyright (C) 2004, 2005, 2006 Rob Buis <buis@kde.org>
  *
  * 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,
@@ skipping 32 matching lines @@
 SVGGraphicsElement::SVGGraphicsElement(const QualifiedName& tagName, Document& document, ConstructionType constructionType)
     : SVGElement(tagName, document, constructionType)
 {
     registerAnimatedPropertiesForSVGGraphicsElement();
 }
 
 SVGGraphicsElement::~SVGGraphicsElement()
 {
 }
 
+AffineTransform SVGGraphicsElement::getTransformToElement(SVGElement* target, ExceptionState& es)
+{
+    AffineTransform ctm = getCTM(AllowStyleUpdate);
+
+    if (target && target->isSVGGraphicsElement()) {
+        AffineTransform targetCTM = toSVGGraphicsElement(target)->getCTM(AllowStyleUpdate);
+        if (!targetCTM.isInvertible()) {
+            es.throwUninformativeAndGenericDOMException(InvalidStateError);
+            return ctm;
+        }
+        ctm = targetCTM.inverse() * ctm;
+    }
+
+    return ctm;
+}
+
+static AffineTransform computeCTM(SVGGraphicsElement* element, SVGElement::CTMScope mode, SVGGraphicsElement::StyleUpdateStrategy styleUpdateStrategy)
+{
+    ASSERT(element);
+    if (styleUpdateStrategy == SVGGraphicsElement::AllowStyleUpdate)
+        element->document().updateLayoutIgnorePendingStylesheets();
+
+    AffineTransform ctm;
+
+    SVGElement* stopAtElement = mode == SVGGraphicsElement::NearestViewportScope ? element->nearestViewportElement() : 0;
+    for (Element* currentElement = element; currentElement; currentElement = currentElement->parentOrShadowHostElement()) {
+        if (!currentElement->isSVGElement())
+            break;
+
+        ctm = toSVGElement(currentElement)->localCoordinateSpaceTransform(mode).multiply(ctm);
+
+        // For getCTM() computation, stop at the nearest viewport element
+        if (currentElement == stopAtElement)
+            break;
+    }
+
+    return ctm;
+}
+
 AffineTransform SVGGraphicsElement::getCTM(StyleUpdateStrategy styleUpdateStrategy)
 {
-    return SVGLocatable::computeCTM(this, SVGLocatable::NearestViewportScope, styleUpdateStrategy);
+    return computeCTM(this, NearestViewportScope, styleUpdateStrategy);
 }
 
 AffineTransform SVGGraphicsElement::getScreenCTM(StyleUpdateStrategy styleUpdateStrategy)
 {
-    return SVGLocatable::computeCTM(this, SVGLocatable::ScreenScope, styleUpdateStrategy);
+    return computeCTM(this, ScreenScope, styleUpdateStrategy);
 }
 
 AffineTransform SVGGraphicsElement::animatedLocalTransform() const
 {
     AffineTransform matrix;
     RenderStyle* style = renderer() ? renderer()->style() : 0;
 
     // If CSS property was set, use that, otherwise fallback to attribute (if set).
     if (style && style->hasTransform()) {
         // Note: objectBoundingBox is an emptyRect for elements like pattern or clipPath.
@@ skipping 78 matching lines @@
 
     if (attrName == SVGNames::transformAttr) {
         object->setNeedsTransformUpdate();
         RenderSVGResource::markForLayoutAndParentResourceInvalidation(object);
         return;
     }
 
     ASSERT_NOT_REACHED();
 }
 
+static bool isViewportElement(Node* node)
+{
+    return (node->hasTagName(SVGNames::svgTag)
+        || node->hasTagName(SVGNames::symbolTag)
+        || node->hasTagName(SVGNames::foreignObjectTag)
+        || node->hasTagName(SVGNames::imageTag));
+}
+
 SVGElement* SVGGraphicsElement::nearestViewportElement() const
 {
-    return SVGTransformable::nearestViewportElement(this);
+    for (Element* current = parentOrShadowHostElement(); current; current = current->parentOrShadowHostElement()) {
+        if (isViewportElement(current))
+            return toSVGElement(current);
+    }
+
+    return 0;
 }
 
 SVGElement* SVGGraphicsElement::farthestViewportElement() const
 {
-    return SVGTransformable::farthestViewportElement(this);
+    SVGElement* farthest = 0;
+    for (Element* current = parentOrShadowHostElement(); current; current = current->parentOrShadowHostElement()) {
+        if (isViewportElement(current))
+            farthest = toSVGElement(current);
+    }
+    return farthest;
 }
 
 SVGRect SVGGraphicsElement::getBBox()
 {
     document().updateLayoutIgnorePendingStylesheets();
 
     // FIXME: Eventually we should support getBBox for detached elements.
     if (!renderer())
         return SVGRect();
 
@@ skipping 18 matching lines @@
 }
 
 void SVGGraphicsElement::toClipPath(Path& path)
 {
     updatePathFromGraphicsElement(this, path);
     // FIXME: How do we know the element has done a layout?
     path.transform(animatedLocalTransform());
 }
 
 }