Reviewed by Oliver.
authorweinig <weinig@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 3 Jul 2007 20:46:44 +0000 (20:46 +0000)
committerweinig <weinig@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 3 Jul 2007 20:46:44 +0000 (20:46 +0000)
        Eighth round of fixes for implicit 64-32 bit conversion errors.
        <rdar://problem/5292262>

        - Convert SVG implementation files to use floats instead of doubles
          to match the spec/IDLs.

        * bindings/scripts/CodeGeneratorJS.pm:
        * ksvg2/svg/SVGAngle.cpp:
        * ksvg2/svg/SVGAnimatedTemplate.h:
        * ksvg2/svg/SVGAnimationElement.cpp:
        (WebCore::SVGAnimationElement::getEndTime):
        (WebCore::SVGAnimationElement::getStartTime):
        (WebCore::SVGAnimationElement::getCurrentTime):
        (WebCore::SVGAnimationElement::getSimpleDuration):
        * ksvg2/svg/SVGAnimationElement.h:
        * ksvg2/svg/SVGFitToViewBox.cpp:
        (WebCore::SVGFitToViewBox::parseViewBox):
        * ksvg2/svg/SVGLength.cpp:
        (WebCore::SVGLength::setValueAsString):
        * ksvg2/svg/SVGLinearGradientElement.cpp:
        (WebCore::SVGLinearGradientElement::buildGradient):
        * ksvg2/svg/SVGMatrix.idl:
        * ksvg2/svg/SVGNumber.idl:
        * ksvg2/svg/SVGParserUtilities.cpp:
        (WebCore::SVGPathParser::parseSVG):
        (WebCore::SVGPathParser::calculateArc):
        (WebCore::SVGPathParser::svgLineToHorizontal):
        (WebCore::SVGPathParser::svgLineToVertical):
        (WebCore::SVGPathParser::svgCurveToCubicSmooth):
        (WebCore::SVGPathParser::svgCurveToQuadratic):
        (WebCore::SVGPathParser::svgCurveToQuadraticSmooth):
        (WebCore::SVGPathParser::svgArcTo):
        * ksvg2/svg/SVGParserUtilities.h:
        * ksvg2/svg/SVGPathElement.cpp:
        (WebCore::SVGPathElement::SVGPathElement):
        (WebCore::SVGPathElement::getTotalLength):
        (WebCore::SVGPathElement::getPointAtLength):
        (WebCore::SVGPathElement::getPathSegAtLength):
        (WebCore::SVGPathElement::createSVGPathSegMovetoAbs):
        (WebCore::SVGPathElement::createSVGPathSegMovetoRel):
        (WebCore::SVGPathElement::createSVGPathSegLinetoAbs):
        (WebCore::SVGPathElement::createSVGPathSegLinetoRel):
        (WebCore::SVGPathElement::createSVGPathSegCurvetoCubicAbs):
        (WebCore::SVGPathElement::createSVGPathSegCurvetoCubicRel):
        (WebCore::SVGPathElement::createSVGPathSegCurvetoQuadraticAbs):
        (WebCore::SVGPathElement::createSVGPathSegCurvetoQuadraticRel):
        (WebCore::SVGPathElement::createSVGPathSegArcAbs):
        (WebCore::SVGPathElement::createSVGPathSegArcRel):
        (WebCore::SVGPathElement::createSVGPathSegLinetoHorizontalAbs):
        (WebCore::SVGPathElement::createSVGPathSegLinetoHorizontalRel):
        (WebCore::SVGPathElement::createSVGPathSegLinetoVerticalAbs):
        (WebCore::SVGPathElement::createSVGPathSegLinetoVerticalRel):
        (WebCore::SVGPathElement::createSVGPathSegCurvetoCubicSmoothAbs):
        (WebCore::SVGPathElement::createSVGPathSegCurvetoCubicSmoothRel):
        (WebCore::SVGPathElement::createSVGPathSegCurvetoQuadraticSmoothAbs):
        (WebCore::SVGPathElement::createSVGPathSegCurvetoQuadraticSmoothRel):
        (WebCore::SVGPathElement::svgMoveTo):
        (WebCore::SVGPathElement::svgLineTo):
        (WebCore::SVGPathElement::svgLineToHorizontal):
        (WebCore::SVGPathElement::svgLineToVertical):
        (WebCore::SVGPathElement::svgCurveToCubic):
        (WebCore::SVGPathElement::svgCurveToCubicSmooth):
        (WebCore::SVGPathElement::svgCurveToQuadratic):
        (WebCore::SVGPathElement::svgCurveToQuadraticSmooth):
        (WebCore::SVGPathElement::svgArcTo):
        (WebCore::SVGPathElement::parseMappedAttribute):
        * ksvg2/svg/SVGPathElement.h:
        * ksvg2/svg/SVGPathSegArc.cpp:
        (WebCore::SVGPathSegArcAbs::SVGPathSegArcAbs):
        (WebCore::SVGPathSegArcAbs::setX):
        (WebCore::SVGPathSegArcAbs::x):
        (WebCore::SVGPathSegArcAbs::setY):
        (WebCore::SVGPathSegArcAbs::y):
        (WebCore::SVGPathSegArcAbs::setR1):
        (WebCore::SVGPathSegArcAbs::r1):
        (WebCore::SVGPathSegArcAbs::setR2):
        (WebCore::SVGPathSegArcAbs::r2):
        (WebCore::SVGPathSegArcAbs::setAngle):
        (WebCore::SVGPathSegArcAbs::angle):
        (WebCore::SVGPathSegArcRel::SVGPathSegArcRel):
        (WebCore::SVGPathSegArcRel::setX):
        (WebCore::SVGPathSegArcRel::x):
        (WebCore::SVGPathSegArcRel::setY):
        (WebCore::SVGPathSegArcRel::y):
        (WebCore::SVGPathSegArcRel::setR1):
        (WebCore::SVGPathSegArcRel::r1):
        (WebCore::SVGPathSegArcRel::setR2):
        (WebCore::SVGPathSegArcRel::r2):
        (WebCore::SVGPathSegArcRel::setAngle):
        (WebCore::SVGPathSegArcRel::angle):
        * ksvg2/svg/SVGPathSegArc.h:
        * ksvg2/svg/SVGPathSegCurvetoCubic.cpp:
        (WebCore::SVGPathSegCurvetoCubicAbs::SVGPathSegCurvetoCubicAbs):
        (WebCore::SVGPathSegCurvetoCubicAbs::setX):
        (WebCore::SVGPathSegCurvetoCubicAbs::x):
        (WebCore::SVGPathSegCurvetoCubicAbs::setY):
        (WebCore::SVGPathSegCurvetoCubicAbs::y):
        (WebCore::SVGPathSegCurvetoCubicAbs::setX1):
        (WebCore::SVGPathSegCurvetoCubicAbs::x1):
        (WebCore::SVGPathSegCurvetoCubicAbs::setY1):
        (WebCore::SVGPathSegCurvetoCubicAbs::y1):
        (WebCore::SVGPathSegCurvetoCubicAbs::setX2):
        (WebCore::SVGPathSegCurvetoCubicAbs::x2):
        (WebCore::SVGPathSegCurvetoCubicAbs::setY2):
        (WebCore::SVGPathSegCurvetoCubicAbs::y2):
        (WebCore::SVGPathSegCurvetoCubicRel::SVGPathSegCurvetoCubicRel):
        (WebCore::SVGPathSegCurvetoCubicRel::setX):
        (WebCore::SVGPathSegCurvetoCubicRel::x):
        (WebCore::SVGPathSegCurvetoCubicRel::setY):
        (WebCore::SVGPathSegCurvetoCubicRel::y):
        (WebCore::SVGPathSegCurvetoCubicRel::setX1):
        (WebCore::SVGPathSegCurvetoCubicRel::x1):
        (WebCore::SVGPathSegCurvetoCubicRel::setY1):
        (WebCore::SVGPathSegCurvetoCubicRel::y1):
        (WebCore::SVGPathSegCurvetoCubicRel::setX2):
        (WebCore::SVGPathSegCurvetoCubicRel::x2):
        (WebCore::SVGPathSegCurvetoCubicRel::setY2):
        (WebCore::SVGPathSegCurvetoCubicRel::y2):
        * ksvg2/svg/SVGPathSegCurvetoCubic.h:
        * ksvg2/svg/SVGPathSegCurvetoCubicSmooth.cpp:
        (WebCore::SVGPathSegCurvetoCubicSmoothAbs::SVGPathSegCurvetoCubicSmoothAbs):
        (WebCore::SVGPathSegCurvetoCubicSmoothAbs::setX):
        (WebCore::SVGPathSegCurvetoCubicSmoothAbs::x):
        (WebCore::SVGPathSegCurvetoCubicSmoothAbs::setY):
        (WebCore::SVGPathSegCurvetoCubicSmoothAbs::y):
        (WebCore::SVGPathSegCurvetoCubicSmoothAbs::setX2):
        (WebCore::SVGPathSegCurvetoCubicSmoothAbs::x2):
        (WebCore::SVGPathSegCurvetoCubicSmoothAbs::setY2):
        (WebCore::SVGPathSegCurvetoCubicSmoothAbs::y2):
        (WebCore::SVGPathSegCurvetoCubicSmoothRel::SVGPathSegCurvetoCubicSmoothRel):
        (WebCore::SVGPathSegCurvetoCubicSmoothRel::setX):
        (WebCore::SVGPathSegCurvetoCubicSmoothRel::x):
        (WebCore::SVGPathSegCurvetoCubicSmoothRel::setY):
        (WebCore::SVGPathSegCurvetoCubicSmoothRel::y):
        (WebCore::SVGPathSegCurvetoCubicSmoothRel::setX2):
        (WebCore::SVGPathSegCurvetoCubicSmoothRel::x2):
        (WebCore::SVGPathSegCurvetoCubicSmoothRel::setY2):
        (WebCore::SVGPathSegCurvetoCubicSmoothRel::y2):
        * ksvg2/svg/SVGPathSegCurvetoCubicSmooth.h:
        * ksvg2/svg/SVGPathSegCurvetoQuadratic.cpp:
        (WebCore::SVGPathSegCurvetoQuadraticAbs::SVGPathSegCurvetoQuadraticAbs):
        (WebCore::SVGPathSegCurvetoQuadraticAbs::setX):
        (WebCore::SVGPathSegCurvetoQuadraticAbs::x):
        (WebCore::SVGPathSegCurvetoQuadraticAbs::setY):
        (WebCore::SVGPathSegCurvetoQuadraticAbs::y):
        (WebCore::SVGPathSegCurvetoQuadraticAbs::setX1):
        (WebCore::SVGPathSegCurvetoQuadraticAbs::x1):
        (WebCore::SVGPathSegCurvetoQuadraticAbs::setY1):
        (WebCore::SVGPathSegCurvetoQuadraticAbs::y1):
        (WebCore::SVGPathSegCurvetoQuadraticRel::SVGPathSegCurvetoQuadraticRel):
        (WebCore::SVGPathSegCurvetoQuadraticRel::setX):
        (WebCore::SVGPathSegCurvetoQuadraticRel::x):
        (WebCore::SVGPathSegCurvetoQuadraticRel::setY):
        (WebCore::SVGPathSegCurvetoQuadraticRel::y):
        (WebCore::SVGPathSegCurvetoQuadraticRel::setX1):
        (WebCore::SVGPathSegCurvetoQuadraticRel::x1):
        (WebCore::SVGPathSegCurvetoQuadraticRel::setY1):
        (WebCore::SVGPathSegCurvetoQuadraticRel::y1):
        * ksvg2/svg/SVGPathSegCurvetoQuadratic.h:
        (WebCore::SVGPathSegCurvetoQuadraticRel::toString):
        * ksvg2/svg/SVGPathSegCurvetoQuadraticSmooth.cpp:
        (WebCore::SVGPathSegCurvetoQuadraticSmoothAbs::SVGPathSegCurvetoQuadraticSmoothAbs):
        (WebCore::SVGPathSegCurvetoQuadraticSmoothAbs::setX):
        (WebCore::SVGPathSegCurvetoQuadraticSmoothAbs::x):
        (WebCore::SVGPathSegCurvetoQuadraticSmoothAbs::setY):
        (WebCore::SVGPathSegCurvetoQuadraticSmoothAbs::y):
        (WebCore::SVGPathSegCurvetoQuadraticSmoothRel::SVGPathSegCurvetoQuadraticSmoothRel):
        (WebCore::SVGPathSegCurvetoQuadraticSmoothRel::setX):
        (WebCore::SVGPathSegCurvetoQuadraticSmoothRel::x):
        (WebCore::SVGPathSegCurvetoQuadraticSmoothRel::setY):
        (WebCore::SVGPathSegCurvetoQuadraticSmoothRel::y):
        * ksvg2/svg/SVGPathSegCurvetoQuadraticSmooth.h:
        * ksvg2/svg/SVGPathSegLineto.cpp:
        (WebCore::SVGPathSegLinetoAbs::SVGPathSegLinetoAbs):
        (WebCore::SVGPathSegLinetoAbs::setX):
        (WebCore::SVGPathSegLinetoAbs::x):
        (WebCore::SVGPathSegLinetoAbs::setY):
        (WebCore::SVGPathSegLinetoAbs::y):
        (WebCore::SVGPathSegLinetoRel::SVGPathSegLinetoRel):
        (WebCore::SVGPathSegLinetoRel::setX):
        (WebCore::SVGPathSegLinetoRel::x):
        (WebCore::SVGPathSegLinetoRel::setY):
        (WebCore::SVGPathSegLinetoRel::y):
        * ksvg2/svg/SVGPathSegLineto.h:
        * ksvg2/svg/SVGPathSegLinetoHorizontal.cpp:
        (WebCore::SVGPathSegLinetoHorizontalAbs::SVGPathSegLinetoHorizontalAbs):
        (WebCore::SVGPathSegLinetoHorizontalAbs::setX):
        (WebCore::SVGPathSegLinetoHorizontalAbs::x):
        (WebCore::SVGPathSegLinetoHorizontalRel::SVGPathSegLinetoHorizontalRel):
        (WebCore::SVGPathSegLinetoHorizontalRel::setX):
        (WebCore::SVGPathSegLinetoHorizontalRel::x):
        * ksvg2/svg/SVGPathSegLinetoHorizontal.h:
        * ksvg2/svg/SVGPathSegLinetoVertical.cpp:
        (WebCore::SVGPathSegLinetoVerticalAbs::SVGPathSegLinetoVerticalAbs):
        (WebCore::SVGPathSegLinetoVerticalAbs::setY):
        (WebCore::SVGPathSegLinetoVerticalAbs::y):
        (WebCore::SVGPathSegLinetoVerticalRel::SVGPathSegLinetoVerticalRel):
        (WebCore::SVGPathSegLinetoVerticalRel::setY):
        (WebCore::SVGPathSegLinetoVerticalRel::y):
        * ksvg2/svg/SVGPathSegLinetoVertical.h:
        * ksvg2/svg/SVGPathSegList.cpp:
        (WebCore::SVGPathSegList::getPathSegAtLength):
        * ksvg2/svg/SVGPathSegList.h:
        * ksvg2/svg/SVGPathSegMoveto.cpp:
        (WebCore::SVGPathSegMovetoAbs::SVGPathSegMovetoAbs):
        (WebCore::SVGPathSegMovetoAbs::setX):
        (WebCore::SVGPathSegMovetoAbs::x):
        (WebCore::SVGPathSegMovetoAbs::setY):
        (WebCore::SVGPathSegMovetoAbs::y):
        (WebCore::SVGPathSegMovetoRel::SVGPathSegMovetoRel):
        (WebCore::SVGPathSegMovetoRel::setX):
        (WebCore::SVGPathSegMovetoRel::x):
        (WebCore::SVGPathSegMovetoRel::setY):
        (WebCore::SVGPathSegMovetoRel::y):
        * ksvg2/svg/SVGPathSegMoveto.h:
        * ksvg2/svg/SVGPolyElement.cpp:
        (WebCore::SVGPolyElement::svgPolyTo):
        * ksvg2/svg/SVGRadialGradientElement.cpp:
        (WebCore::SVGRadialGradientElement::buildGradient):
        * ksvg2/svg/SVGSVGElement.cpp:
        (WebCore::SVGSVGElement::viewport):
        (WebCore::SVGSVGElement::getCurrentTime):
        * ksvg2/svg/SVGStopElement.cpp:
        (WebCore::SVGStopElement::SVGStopElement):
        (WebCore::SVGStopElement::parseMappedAttribute):
        * ksvg2/svg/SVGStopElement.h:
        * ksvg2/svg/SVGTransform.cpp:
        (SVGTransform::translate):
        (SVGTransform::scale):
        * ksvg2/svg/SVGTransformDistance.cpp:
        (WebCore::SVGTransformDistance::addToSVGTransform):
        (WebCore::SVGTransformDistance::distance):
        * ksvg2/svg/SVGTransformable.cpp:
        (WebCore::SVGTransformable::parseTransformAttribute):

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@23951 268f45cc-cd09-0410-ab3c-d52691b4dbfc

44 files changed:
WebCore/ChangeLog
WebCore/WebCore.xcodeproj/project.pbxproj
WebCore/bindings/scripts/CodeGeneratorJS.pm
WebCore/ksvg2/svg/SVGAngle.cpp
WebCore/ksvg2/svg/SVGAnimatedTemplate.h
WebCore/ksvg2/svg/SVGAnimationElement.cpp
WebCore/ksvg2/svg/SVGAnimationElement.h
WebCore/ksvg2/svg/SVGFitToViewBox.cpp
WebCore/ksvg2/svg/SVGLength.cpp
WebCore/ksvg2/svg/SVGLinearGradientElement.cpp
WebCore/ksvg2/svg/SVGMatrix.idl
WebCore/ksvg2/svg/SVGNumber.idl
WebCore/ksvg2/svg/SVGParserUtilities.cpp
WebCore/ksvg2/svg/SVGParserUtilities.h
WebCore/ksvg2/svg/SVGPathElement.cpp
WebCore/ksvg2/svg/SVGPathElement.h
WebCore/ksvg2/svg/SVGPathSegArc.cpp
WebCore/ksvg2/svg/SVGPathSegArc.h
WebCore/ksvg2/svg/SVGPathSegCurvetoCubic.cpp
WebCore/ksvg2/svg/SVGPathSegCurvetoCubic.h
WebCore/ksvg2/svg/SVGPathSegCurvetoCubicSmooth.cpp
WebCore/ksvg2/svg/SVGPathSegCurvetoCubicSmooth.h
WebCore/ksvg2/svg/SVGPathSegCurvetoQuadratic.cpp
WebCore/ksvg2/svg/SVGPathSegCurvetoQuadratic.h
WebCore/ksvg2/svg/SVGPathSegCurvetoQuadraticSmooth.cpp
WebCore/ksvg2/svg/SVGPathSegCurvetoQuadraticSmooth.h
WebCore/ksvg2/svg/SVGPathSegLineto.cpp
WebCore/ksvg2/svg/SVGPathSegLineto.h
WebCore/ksvg2/svg/SVGPathSegLinetoHorizontal.cpp
WebCore/ksvg2/svg/SVGPathSegLinetoHorizontal.h
WebCore/ksvg2/svg/SVGPathSegLinetoVertical.cpp
WebCore/ksvg2/svg/SVGPathSegLinetoVertical.h
WebCore/ksvg2/svg/SVGPathSegList.cpp
WebCore/ksvg2/svg/SVGPathSegList.h
WebCore/ksvg2/svg/SVGPathSegMoveto.cpp
WebCore/ksvg2/svg/SVGPathSegMoveto.h
WebCore/ksvg2/svg/SVGPolyElement.cpp
WebCore/ksvg2/svg/SVGRadialGradientElement.cpp
WebCore/ksvg2/svg/SVGSVGElement.cpp
WebCore/ksvg2/svg/SVGStopElement.cpp
WebCore/ksvg2/svg/SVGStopElement.h
WebCore/ksvg2/svg/SVGTransform.cpp
WebCore/ksvg2/svg/SVGTransformDistance.cpp
WebCore/ksvg2/svg/SVGTransformable.cpp

index aeabeffe705cd4bc7e3615ea89ae6243c4be962b..4246e961b9511cdf2fa694a64ad742f707402c6e 100644 (file)
@@ -1,3 +1,242 @@
+2007-07-03  Sam Weinig  <sam@webkit.org>
+
+        Reviewed by Oliver.
+
+        Eighth round of fixes for implicit 64-32 bit conversion errors.
+        <rdar://problem/5292262>
+
+        - Convert SVG implementation files to use floats instead of doubles
+          to match the spec/IDLs.
+
+        * bindings/scripts/CodeGeneratorJS.pm:
+        * ksvg2/svg/SVGAngle.cpp:
+        * ksvg2/svg/SVGAnimatedTemplate.h:
+        * ksvg2/svg/SVGAnimationElement.cpp:
+        (WebCore::SVGAnimationElement::getEndTime):
+        (WebCore::SVGAnimationElement::getStartTime):
+        (WebCore::SVGAnimationElement::getCurrentTime):
+        (WebCore::SVGAnimationElement::getSimpleDuration):
+        * ksvg2/svg/SVGAnimationElement.h:
+        * ksvg2/svg/SVGFitToViewBox.cpp:
+        (WebCore::SVGFitToViewBox::parseViewBox):
+        * ksvg2/svg/SVGLength.cpp:
+        (WebCore::SVGLength::setValueAsString):
+        * ksvg2/svg/SVGLinearGradientElement.cpp:
+        (WebCore::SVGLinearGradientElement::buildGradient):
+        * ksvg2/svg/SVGMatrix.idl:
+        * ksvg2/svg/SVGNumber.idl:
+        * ksvg2/svg/SVGParserUtilities.cpp:
+        (WebCore::SVGPathParser::parseSVG):
+        (WebCore::SVGPathParser::calculateArc):
+        (WebCore::SVGPathParser::svgLineToHorizontal):
+        (WebCore::SVGPathParser::svgLineToVertical):
+        (WebCore::SVGPathParser::svgCurveToCubicSmooth):
+        (WebCore::SVGPathParser::svgCurveToQuadratic):
+        (WebCore::SVGPathParser::svgCurveToQuadraticSmooth):
+        (WebCore::SVGPathParser::svgArcTo):
+        * ksvg2/svg/SVGParserUtilities.h:
+        * ksvg2/svg/SVGPathElement.cpp:
+        (WebCore::SVGPathElement::SVGPathElement):
+        (WebCore::SVGPathElement::getTotalLength):
+        (WebCore::SVGPathElement::getPointAtLength):
+        (WebCore::SVGPathElement::getPathSegAtLength):
+        (WebCore::SVGPathElement::createSVGPathSegMovetoAbs):
+        (WebCore::SVGPathElement::createSVGPathSegMovetoRel):
+        (WebCore::SVGPathElement::createSVGPathSegLinetoAbs):
+        (WebCore::SVGPathElement::createSVGPathSegLinetoRel):
+        (WebCore::SVGPathElement::createSVGPathSegCurvetoCubicAbs):
+        (WebCore::SVGPathElement::createSVGPathSegCurvetoCubicRel):
+        (WebCore::SVGPathElement::createSVGPathSegCurvetoQuadraticAbs):
+        (WebCore::SVGPathElement::createSVGPathSegCurvetoQuadraticRel):
+        (WebCore::SVGPathElement::createSVGPathSegArcAbs):
+        (WebCore::SVGPathElement::createSVGPathSegArcRel):
+        (WebCore::SVGPathElement::createSVGPathSegLinetoHorizontalAbs):
+        (WebCore::SVGPathElement::createSVGPathSegLinetoHorizontalRel):
+        (WebCore::SVGPathElement::createSVGPathSegLinetoVerticalAbs):
+        (WebCore::SVGPathElement::createSVGPathSegLinetoVerticalRel):
+        (WebCore::SVGPathElement::createSVGPathSegCurvetoCubicSmoothAbs):
+        (WebCore::SVGPathElement::createSVGPathSegCurvetoCubicSmoothRel):
+        (WebCore::SVGPathElement::createSVGPathSegCurvetoQuadraticSmoothAbs):
+        (WebCore::SVGPathElement::createSVGPathSegCurvetoQuadraticSmoothRel):
+        (WebCore::SVGPathElement::svgMoveTo):
+        (WebCore::SVGPathElement::svgLineTo):
+        (WebCore::SVGPathElement::svgLineToHorizontal):
+        (WebCore::SVGPathElement::svgLineToVertical):
+        (WebCore::SVGPathElement::svgCurveToCubic):
+        (WebCore::SVGPathElement::svgCurveToCubicSmooth):
+        (WebCore::SVGPathElement::svgCurveToQuadratic):
+        (WebCore::SVGPathElement::svgCurveToQuadraticSmooth):
+        (WebCore::SVGPathElement::svgArcTo):
+        (WebCore::SVGPathElement::parseMappedAttribute):
+        * ksvg2/svg/SVGPathElement.h:
+        * ksvg2/svg/SVGPathSegArc.cpp:
+        (WebCore::SVGPathSegArcAbs::SVGPathSegArcAbs):
+        (WebCore::SVGPathSegArcAbs::setX):
+        (WebCore::SVGPathSegArcAbs::x):
+        (WebCore::SVGPathSegArcAbs::setY):
+        (WebCore::SVGPathSegArcAbs::y):
+        (WebCore::SVGPathSegArcAbs::setR1):
+        (WebCore::SVGPathSegArcAbs::r1):
+        (WebCore::SVGPathSegArcAbs::setR2):
+        (WebCore::SVGPathSegArcAbs::r2):
+        (WebCore::SVGPathSegArcAbs::setAngle):
+        (WebCore::SVGPathSegArcAbs::angle):
+        (WebCore::SVGPathSegArcRel::SVGPathSegArcRel):
+        (WebCore::SVGPathSegArcRel::setX):
+        (WebCore::SVGPathSegArcRel::x):
+        (WebCore::SVGPathSegArcRel::setY):
+        (WebCore::SVGPathSegArcRel::y):
+        (WebCore::SVGPathSegArcRel::setR1):
+        (WebCore::SVGPathSegArcRel::r1):
+        (WebCore::SVGPathSegArcRel::setR2):
+        (WebCore::SVGPathSegArcRel::r2):
+        (WebCore::SVGPathSegArcRel::setAngle):
+        (WebCore::SVGPathSegArcRel::angle):
+        * ksvg2/svg/SVGPathSegArc.h:
+        * ksvg2/svg/SVGPathSegCurvetoCubic.cpp:
+        (WebCore::SVGPathSegCurvetoCubicAbs::SVGPathSegCurvetoCubicAbs):
+        (WebCore::SVGPathSegCurvetoCubicAbs::setX):
+        (WebCore::SVGPathSegCurvetoCubicAbs::x):
+        (WebCore::SVGPathSegCurvetoCubicAbs::setY):
+        (WebCore::SVGPathSegCurvetoCubicAbs::y):
+        (WebCore::SVGPathSegCurvetoCubicAbs::setX1):
+        (WebCore::SVGPathSegCurvetoCubicAbs::x1):
+        (WebCore::SVGPathSegCurvetoCubicAbs::setY1):
+        (WebCore::SVGPathSegCurvetoCubicAbs::y1):
+        (WebCore::SVGPathSegCurvetoCubicAbs::setX2):
+        (WebCore::SVGPathSegCurvetoCubicAbs::x2):
+        (WebCore::SVGPathSegCurvetoCubicAbs::setY2):
+        (WebCore::SVGPathSegCurvetoCubicAbs::y2):
+        (WebCore::SVGPathSegCurvetoCubicRel::SVGPathSegCurvetoCubicRel):
+        (WebCore::SVGPathSegCurvetoCubicRel::setX):
+        (WebCore::SVGPathSegCurvetoCubicRel::x):
+        (WebCore::SVGPathSegCurvetoCubicRel::setY):
+        (WebCore::SVGPathSegCurvetoCubicRel::y):
+        (WebCore::SVGPathSegCurvetoCubicRel::setX1):
+        (WebCore::SVGPathSegCurvetoCubicRel::x1):
+        (WebCore::SVGPathSegCurvetoCubicRel::setY1):
+        (WebCore::SVGPathSegCurvetoCubicRel::y1):
+        (WebCore::SVGPathSegCurvetoCubicRel::setX2):
+        (WebCore::SVGPathSegCurvetoCubicRel::x2):
+        (WebCore::SVGPathSegCurvetoCubicRel::setY2):
+        (WebCore::SVGPathSegCurvetoCubicRel::y2):
+        * ksvg2/svg/SVGPathSegCurvetoCubic.h:
+        * ksvg2/svg/SVGPathSegCurvetoCubicSmooth.cpp:
+        (WebCore::SVGPathSegCurvetoCubicSmoothAbs::SVGPathSegCurvetoCubicSmoothAbs):
+        (WebCore::SVGPathSegCurvetoCubicSmoothAbs::setX):
+        (WebCore::SVGPathSegCurvetoCubicSmoothAbs::x):
+        (WebCore::SVGPathSegCurvetoCubicSmoothAbs::setY):
+        (WebCore::SVGPathSegCurvetoCubicSmoothAbs::y):
+        (WebCore::SVGPathSegCurvetoCubicSmoothAbs::setX2):
+        (WebCore::SVGPathSegCurvetoCubicSmoothAbs::x2):
+        (WebCore::SVGPathSegCurvetoCubicSmoothAbs::setY2):
+        (WebCore::SVGPathSegCurvetoCubicSmoothAbs::y2):
+        (WebCore::SVGPathSegCurvetoCubicSmoothRel::SVGPathSegCurvetoCubicSmoothRel):
+        (WebCore::SVGPathSegCurvetoCubicSmoothRel::setX):
+        (WebCore::SVGPathSegCurvetoCubicSmoothRel::x):
+        (WebCore::SVGPathSegCurvetoCubicSmoothRel::setY):
+        (WebCore::SVGPathSegCurvetoCubicSmoothRel::y):
+        (WebCore::SVGPathSegCurvetoCubicSmoothRel::setX2):
+        (WebCore::SVGPathSegCurvetoCubicSmoothRel::x2):
+        (WebCore::SVGPathSegCurvetoCubicSmoothRel::setY2):
+        (WebCore::SVGPathSegCurvetoCubicSmoothRel::y2):
+        * ksvg2/svg/SVGPathSegCurvetoCubicSmooth.h:
+        * ksvg2/svg/SVGPathSegCurvetoQuadratic.cpp:
+        (WebCore::SVGPathSegCurvetoQuadraticAbs::SVGPathSegCurvetoQuadraticAbs):
+        (WebCore::SVGPathSegCurvetoQuadraticAbs::setX):
+        (WebCore::SVGPathSegCurvetoQuadraticAbs::x):
+        (WebCore::SVGPathSegCurvetoQuadraticAbs::setY):
+        (WebCore::SVGPathSegCurvetoQuadraticAbs::y):
+        (WebCore::SVGPathSegCurvetoQuadraticAbs::setX1):
+        (WebCore::SVGPathSegCurvetoQuadraticAbs::x1):
+        (WebCore::SVGPathSegCurvetoQuadraticAbs::setY1):
+        (WebCore::SVGPathSegCurvetoQuadraticAbs::y1):
+        (WebCore::SVGPathSegCurvetoQuadraticRel::SVGPathSegCurvetoQuadraticRel):
+        (WebCore::SVGPathSegCurvetoQuadraticRel::setX):
+        (WebCore::SVGPathSegCurvetoQuadraticRel::x):
+        (WebCore::SVGPathSegCurvetoQuadraticRel::setY):
+        (WebCore::SVGPathSegCurvetoQuadraticRel::y):
+        (WebCore::SVGPathSegCurvetoQuadraticRel::setX1):
+        (WebCore::SVGPathSegCurvetoQuadraticRel::x1):
+        (WebCore::SVGPathSegCurvetoQuadraticRel::setY1):
+        (WebCore::SVGPathSegCurvetoQuadraticRel::y1):
+        * ksvg2/svg/SVGPathSegCurvetoQuadratic.h:
+        (WebCore::SVGPathSegCurvetoQuadraticRel::toString):
+        * ksvg2/svg/SVGPathSegCurvetoQuadraticSmooth.cpp:
+        (WebCore::SVGPathSegCurvetoQuadraticSmoothAbs::SVGPathSegCurvetoQuadraticSmoothAbs):
+        (WebCore::SVGPathSegCurvetoQuadraticSmoothAbs::setX):
+        (WebCore::SVGPathSegCurvetoQuadraticSmoothAbs::x):
+        (WebCore::SVGPathSegCurvetoQuadraticSmoothAbs::setY):
+        (WebCore::SVGPathSegCurvetoQuadraticSmoothAbs::y):
+        (WebCore::SVGPathSegCurvetoQuadraticSmoothRel::SVGPathSegCurvetoQuadraticSmoothRel):
+        (WebCore::SVGPathSegCurvetoQuadraticSmoothRel::setX):
+        (WebCore::SVGPathSegCurvetoQuadraticSmoothRel::x):
+        (WebCore::SVGPathSegCurvetoQuadraticSmoothRel::setY):
+        (WebCore::SVGPathSegCurvetoQuadraticSmoothRel::y):
+        * ksvg2/svg/SVGPathSegCurvetoQuadraticSmooth.h:
+        * ksvg2/svg/SVGPathSegLineto.cpp:
+        (WebCore::SVGPathSegLinetoAbs::SVGPathSegLinetoAbs):
+        (WebCore::SVGPathSegLinetoAbs::setX):
+        (WebCore::SVGPathSegLinetoAbs::x):
+        (WebCore::SVGPathSegLinetoAbs::setY):
+        (WebCore::SVGPathSegLinetoAbs::y):
+        (WebCore::SVGPathSegLinetoRel::SVGPathSegLinetoRel):
+        (WebCore::SVGPathSegLinetoRel::setX):
+        (WebCore::SVGPathSegLinetoRel::x):
+        (WebCore::SVGPathSegLinetoRel::setY):
+        (WebCore::SVGPathSegLinetoRel::y):
+        * ksvg2/svg/SVGPathSegLineto.h:
+        * ksvg2/svg/SVGPathSegLinetoHorizontal.cpp:
+        (WebCore::SVGPathSegLinetoHorizontalAbs::SVGPathSegLinetoHorizontalAbs):
+        (WebCore::SVGPathSegLinetoHorizontalAbs::setX):
+        (WebCore::SVGPathSegLinetoHorizontalAbs::x):
+        (WebCore::SVGPathSegLinetoHorizontalRel::SVGPathSegLinetoHorizontalRel):
+        (WebCore::SVGPathSegLinetoHorizontalRel::setX):
+        (WebCore::SVGPathSegLinetoHorizontalRel::x):
+        * ksvg2/svg/SVGPathSegLinetoHorizontal.h:
+        * ksvg2/svg/SVGPathSegLinetoVertical.cpp:
+        (WebCore::SVGPathSegLinetoVerticalAbs::SVGPathSegLinetoVerticalAbs):
+        (WebCore::SVGPathSegLinetoVerticalAbs::setY):
+        (WebCore::SVGPathSegLinetoVerticalAbs::y):
+        (WebCore::SVGPathSegLinetoVerticalRel::SVGPathSegLinetoVerticalRel):
+        (WebCore::SVGPathSegLinetoVerticalRel::setY):
+        (WebCore::SVGPathSegLinetoVerticalRel::y):
+        * ksvg2/svg/SVGPathSegLinetoVertical.h:
+        * ksvg2/svg/SVGPathSegList.cpp:
+        (WebCore::SVGPathSegList::getPathSegAtLength):
+        * ksvg2/svg/SVGPathSegList.h:
+        * ksvg2/svg/SVGPathSegMoveto.cpp:
+        (WebCore::SVGPathSegMovetoAbs::SVGPathSegMovetoAbs):
+        (WebCore::SVGPathSegMovetoAbs::setX):
+        (WebCore::SVGPathSegMovetoAbs::x):
+        (WebCore::SVGPathSegMovetoAbs::setY):
+        (WebCore::SVGPathSegMovetoAbs::y):
+        (WebCore::SVGPathSegMovetoRel::SVGPathSegMovetoRel):
+        (WebCore::SVGPathSegMovetoRel::setX):
+        (WebCore::SVGPathSegMovetoRel::x):
+        (WebCore::SVGPathSegMovetoRel::setY):
+        (WebCore::SVGPathSegMovetoRel::y):
+        * ksvg2/svg/SVGPathSegMoveto.h:
+        * ksvg2/svg/SVGPolyElement.cpp:
+        (WebCore::SVGPolyElement::svgPolyTo):
+        * ksvg2/svg/SVGRadialGradientElement.cpp:
+        (WebCore::SVGRadialGradientElement::buildGradient):
+        * ksvg2/svg/SVGSVGElement.cpp:
+        (WebCore::SVGSVGElement::viewport):
+        (WebCore::SVGSVGElement::getCurrentTime):
+        * ksvg2/svg/SVGStopElement.cpp:
+        (WebCore::SVGStopElement::SVGStopElement):
+        (WebCore::SVGStopElement::parseMappedAttribute):
+        * ksvg2/svg/SVGStopElement.h:
+        * ksvg2/svg/SVGTransform.cpp:
+        (SVGTransform::translate):
+        (SVGTransform::scale):
+        * ksvg2/svg/SVGTransformDistance.cpp:
+        (WebCore::SVGTransformDistance::addToSVGTransform):
+        (WebCore::SVGTransformDistance::distance):
+        * ksvg2/svg/SVGTransformable.cpp:
+        (WebCore::SVGTransformable::parseTransformAttribute):
+
 2007-07-03  Anders Carlsson  <andersca@apple.com>
 
         Reviewed by Darin.
index 180cd05808e5aada0c55fe4512089d19840a4834..5d810b3970f7773be5da1d5a563d453023b7ed39 100644 (file)
                BC98A27D0C0C9950004BEBF7 /* JSStyleSheetCustom.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BC98A27C0C0C9950004BEBF7 /* JSStyleSheetCustom.cpp */; };
                BCA169A20BFD55B40019CA76 /* JSHTMLTableCaptionElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BCA169A00BFD55B40019CA76 /* JSHTMLTableCaptionElement.cpp */; };
                BCA169A30BFD55B40019CA76 /* JSHTMLTableCaptionElement.h in Headers */ = {isa = PBXBuildFile; fileRef = BCA169A10BFD55B40019CA76 /* JSHTMLTableCaptionElement.h */; };
+               BCA85A100C3AEAF4006F8308 /* DOMSVGNumberInternal.h in Headers */ = {isa = PBXBuildFile; fileRef = BCA85A0F0C3AEAF4006F8308 /* DOMSVGNumberInternal.h */; };
                BCAA90C30A7EBA60008B1229 /* ScrollBar.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BCAA90C20A7EBA60008B1229 /* ScrollBar.cpp */; };
                BCB16B8B0979B01400467741 /* DeprecatedArray.h in Headers */ = {isa = PBXBuildFile; fileRef = BCB16B880979B01400467741 /* DeprecatedArray.h */; settings = {ATTRIBUTES = (Private, ); }; };
                BCB16B8C0979B01400467741 /* ArrayImpl.cpp in Sources */ = {isa = PBXBuildFile; fileRef = BCB16B890979B01400467741 /* ArrayImpl.cpp */; };
                BC98A27C0C0C9950004BEBF7 /* JSStyleSheetCustom.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = JSStyleSheetCustom.cpp; sourceTree = "<group>"; };
                BCA169A00BFD55B40019CA76 /* JSHTMLTableCaptionElement.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = JSHTMLTableCaptionElement.cpp; sourceTree = "<group>"; };
                BCA169A10BFD55B40019CA76 /* JSHTMLTableCaptionElement.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = JSHTMLTableCaptionElement.h; sourceTree = "<group>"; };
+               BCA85A0F0C3AEAF4006F8308 /* DOMSVGNumberInternal.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = DOMSVGNumberInternal.h; sourceTree = "<group>"; };
                BCAA90C20A7EBA60008B1229 /* ScrollBar.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = ScrollBar.cpp; path = platform/ScrollBar.cpp; sourceTree = SOURCE_ROOT; };
                BCB16B880979B01400467741 /* DeprecatedArray.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = DeprecatedArray.h; sourceTree = "<group>"; };
                BCB16B890979B01400467741 /* ArrayImpl.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = ArrayImpl.cpp; sourceTree = "<group>"; };
                85E7113D0AC5D4A10053270F /* Internal */ = {
                        isa = PBXGroup;
                        children = (
+                               BCA85A0F0C3AEAF4006F8308 /* DOMSVGNumberInternal.h */,
                                8538F0180AD718D8006A81D1 /* DOMAbstractViewInternal.h */,
                                85E7113E0AC5D5340053270F /* DOMAttrInternal.h */,
                                85E7113F0AC5D5340053270F /* DOMCDATASectionInternal.h */,
                                BC5A86850C33676000EEA649 /* DOMSelection.h in Headers */,
                                BC5A86B60C3367E800EEA649 /* JSDOMSelection.h in Headers */,
                                BC073BAA0C399B1F000F5979 /* FloatConversion.h in Headers */,
+                               BCA85A100C3AEAF4006F8308 /* DOMSVGNumberInternal.h in Headers */,
                        );
                        runOnlyForDeploymentPostprocessing = 0;
                };
index e2760ab55d98fefb96a1e1af3eee0a990b4d989d..aa9b499cb935a116414391fdf8644a98c8306653 100644 (file)
@@ -1286,7 +1286,7 @@ sub GetNativeType
     my $type = shift;
 
     return "unsigned" if $type eq "unsigned long";
-    return $type if $type eq "unsigned short" or $type eq "float" or $type eq "AtomicString";
+    return $type if $type eq "unsigned short" or $type eq "float" or $type eq "double" or $type eq "AtomicString";
     return "bool" if $type eq "boolean";
     return "int" if $type eq "long";
     return "String" if $type eq "DOMString";
@@ -1314,6 +1314,7 @@ sub TypeCanFailConversion
 
     return 0 if $type eq "boolean" or
                 $type eq "float" or
+                $type eq "double" or
                 $type eq "AtomicString" or
                 $type eq "DOMString" or
                 $type eq "Node" or
@@ -1361,7 +1362,7 @@ sub JSValueToNative
     my $type = $codeGenerator->StripModule($signature->type);
 
     return "$value->toBoolean(exec)" if $type eq "boolean";
-    return "$value->toNumber(exec)" if $type eq "SVGNumber";
+    return "$value->toNumber(exec)" if $type eq "double" or $type eq "SVGNumber";
     return "$value->toFloat(exec)" if $type eq "float";
     return "$value->toInt32(exec${maybeOkParam})" if $type eq "unsigned long" or $type eq "long" or $type eq "unsigned short";
 
index 1a3a56da766b852c1cf696b50ea1cdc14f9b00d5..14b2aa4117d245041036958469c6b2792470530b 100644 (file)
@@ -28,8 +28,8 @@
 
 namespace WebCore {
 
-const float deg2rad = 0.017453292519943295769; // pi/180
-const float deg2grad = 400.0 / 360.0;
+const float deg2rad = 0.017453292519943295769f; // pi/180
+const float deg2grad = 400.0f / 360.0f;
 
 #define rad2grad deg2grad / deg2rad
 
index f1710c7fd450a2f4976773f2070fec4d79831b16..347ed60c98110196875a11516f165692e39166ab 100644 (file)
@@ -57,7 +57,7 @@ namespace WebCore {
     typedef SVGAnimatedTemplate<long> SVGAnimatedInteger;
     typedef SVGAnimatedTemplate<SVGLength> SVGAnimatedLength;
     typedef SVGAnimatedTemplate<SVGLengthList*> SVGAnimatedLengthList;
-    typedef SVGAnimatedTemplate<double> SVGAnimatedNumber;
+    typedef SVGAnimatedTemplate<float> SVGAnimatedNumber;
     typedef SVGAnimatedTemplate<SVGNumberList*> SVGAnimatedNumberList; 
     typedef SVGAnimatedTemplate<SVGPreserveAspectRatio*> SVGAnimatedPreserveAspectRatio;
     typedef SVGAnimatedTemplate<FloatRect> SVGAnimatedRect;
index 65f7bd5c3cbd7977e439e5ae083ee8906f280bf0..a4e283cd7c859c8f2b5df5aedf6842788b5ee2ef 100644 (file)
@@ -97,24 +97,24 @@ SVGElement* SVGAnimationElement::targetElement() const
     return m_targetElement;
 }
 
-double SVGAnimationElement::getEndTime() const
+float SVGAnimationElement::getEndTime() const
 {
-    return m_end;
+    return narrowPrecisionToFloat(m_end);
 }
 
-double SVGAnimationElement::getStartTime() const
+float SVGAnimationElement::getStartTime() const
 {
-    return m_begin;
+    return narrowPrecisionToFloat(m_begin);
 }
 
-double SVGAnimationElement::getCurrentTime() const
+float SVGAnimationElement::getCurrentTime() const
 {
-    return m_currentTime;
+    return narrowPrecisionToFloat(m_currentTime);
 }
 
-double SVGAnimationElement::getSimpleDuration(ExceptionCode&) const
+float SVGAnimationElement::getSimpleDuration(ExceptionCode&) const
 {
-    return m_simpleDuration;
+    return narrowPrecisionToFloat(m_simpleDuration);
 }
 
 void SVGAnimationElement::parseKeyNumbers(Vector<float>& keyNumbers, const String& value)
index aaf9b0ae358b658bad471a95f13690dd48ea2634..57f694064a4caf6a6f60e8997d4eebc37d138c8b 100644 (file)
@@ -91,10 +91,10 @@ namespace WebCore {
         
         virtual bool isValid() const { return SVGTests::isValid(); }
 
-        double getEndTime() const;
-        double getStartTime() const;
-        double getCurrentTime() const;
-        double getSimpleDuration(ExceptionCode&) const;
+        float getEndTime() const;
+        float getStartTime() const;
+        float getCurrentTime() const;
+        float getSimpleDuration(ExceptionCode&) const;
     
         virtual void parseMappedAttribute(MappedAttribute* attr);
 
index 8cbaad757f2a86f46f64e4f0f4790ff24c4396a0..ca9c6ef6f617ecc522cd4bf260411f51ad5a4b14 100644 (file)
@@ -71,7 +71,7 @@ void SVGFitToViewBox::parseViewBox(const String& str)
         if (c < end) // nothing should come after the last, fourth number
             doc->accessSVGExtensions()->reportWarning("Problem parsing viewBox=\"" + str + "\"");
         else
-            setViewBoxBaseValue(FloatRect(x, y, w, h));
+            setViewBoxBaseValue(FloatRect::narrowPrecision(x, y, w, h));
     }
 }
 
index 40ae08798939e73b0ebc494727e97f9cb332cd95..c6087a5e96a9a287f46ad151e2e03fe194714a55 100644 (file)
 #include "SVGLength.h"
 
 #include "DeprecatedString.h"
+#include "FloatConversion.h"
 #include "FrameView.h"
 #include "RenderObject.h"
 #include "RenderView.h"
+#include "SVGParserUtilities.h"
 #include "SVGSVGElement.h"
 #include "SVGStyledElement.h"
-#include "SVGParserUtilities.h"
 #include "csshelper.h"
 
 #include <math.h>
@@ -245,7 +246,7 @@ void SVGLength::setValueAsString(const String& s)
     parseNumber(ptr, end, convertedNumber, false);
 
     m_unit = storeUnit(extractMode(m_unit), stringToLengthType(s));
-    m_valueInSpecifiedUnits = convertedNumber;
+    m_valueInSpecifiedUnits = narrowPrecisionToFloat(convertedNumber);
 }
 
 String SVGLength::valueAsString() const
index 998bda10d3108e46267b490355035ce28616b7b7..cc94de24c05a77afef53b0571ca5134fc170d59f 100644 (file)
 #if ENABLE(SVG)
 #include "SVGLinearGradientElement.h"
 
+#include "FloatPoint.h"
 #include "LinearGradientAttributes.h"
-#include "SVGPaintServerLinearGradient.h"
 #include "SVGLength.h"
 #include "SVGNames.h"
+#include "SVGPaintServerLinearGradient.h"
 #include "SVGTransform.h"
 #include "SVGTransformList.h"
 #include "SVGUnitTypes.h"
@@ -83,8 +84,8 @@ void SVGLinearGradientElement::buildGradient() const
     linearGradient->setBoundingBoxMode(attributes.boundingBoxMode());
     linearGradient->setGradientSpreadMethod(attributes.spreadMethod());
     linearGradient->setGradientTransform(attributes.gradientTransform());
-    linearGradient->setGradientStart(FloatPoint(attributes.x1(), attributes.y1()));
-    linearGradient->setGradientEnd(FloatPoint(attributes.x2(), attributes.y2()));
+    linearGradient->setGradientStart(FloatPoint::narrowPrecision(attributes.x1(), attributes.y1()));
+    linearGradient->setGradientEnd(FloatPoint::narrowPrecision(attributes.x2(), attributes.y2()));
 }
 
 LinearGradientAttributes SVGLinearGradientElement::collectGradientProperties() const
index c112df9c1e99564f587c8b3cbc424f05695bd915..6217b41c81462ac9b4c09646db33c9039a3971d8 100644 (file)
 
 module svg {
 
-    interface [Conditional=SVG, PODType=AffineTransform] SVGMatrix { 
-        attribute float a;
-        attribute float b;
-        attribute float c;
-        attribute float d;
-        attribute float e;
-        attribute float f;
+    interface [Conditional=SVG, PODType=AffineTransform] SVGMatrix {
+        // FIXME: these attributes should all be floats but since we implement
+        // AffineTransform with doubles setting these as doubles makes more sense.
+        attribute double a;
+        attribute double b;
+        attribute double c;
+        attribute double d;
+        attribute double e;
+        attribute double f;
 
         SVGMatrix multiply(in SVGMatrix secondMatrix);
         [Custom] SVGMatrix inverse()
             raises(SVGException);
-        SVGMatrix translate(in float x, in float y);
-        SVGMatrix scale(in float scaleFactor);
-        SVGMatrix scaleNonUniform(in float scaleFactorX, in float scaleFactorY);
-        SVGMatrix rotate(in float angle);
-        [Custom] SVGMatrix rotateFromVector(in float x, in float y)
+        SVGMatrix translate(in double x, in double y);
+        SVGMatrix scale(in double scaleFactor);
+        SVGMatrix scaleNonUniform(in double scaleFactorX, in double scaleFactorY);
+        SVGMatrix rotate(in double angle);
+        [Custom] SVGMatrix rotateFromVector(in double x, in double y)
             raises(SVGException);
         SVGMatrix flipX();
         SVGMatrix flipY();
-        SVGMatrix skewX(in float angle);
-        SVGMatrix skewY(in float angle);
+        SVGMatrix skewX(in double angle);
+        SVGMatrix skewY(in double angle);
     };
 
 }
index 778350e164a08af456c214993cd3cc708e9de630..8c0af5bc24cb9dced0ba3a5818dc71b860350367 100644 (file)
@@ -25,7 +25,8 @@
 module svg {
 
     interface [Conditional=SVG, PODType=double] SVGNumber {
-                 attribute float value
+                 // FIXME: the spec says that this should be a float.
+                 attribute double value
                      setter raises(DOMException);
     };
 
index 63959778a450f6ea6023b1b3d8c36917a5778c78..454ea8cf858c6d7d4a82d3ffcef86aa935430b1f 100644 (file)
@@ -23,6 +23,7 @@
 #if ENABLE(SVG)
 #include "SVGParserUtilities.h"
 
+#include "FloatConversion.h"
 #include "PlatformString.h"
 #include <math.h>
 #include <wtf/MathExtras.h>
@@ -180,9 +181,9 @@ bool SVGPathParser::parseSVG(const String& s, bool process)
                     subpathx = curx = relative ? curx + tox : tox;
                     subpathy = cury = relative ? cury + toy : toy;
 
-                    svgMoveTo(curx, cury, closed);
+                    svgMoveTo(narrowPrecisionToFloat(curx), narrowPrecisionToFloat(cury), closed);
                 } else
-                    svgMoveTo(tox, toy, closed, !relative);
+                    svgMoveTo(narrowPrecisionToFloat(tox), narrowPrecisionToFloat(toy), closed, !relative);
                 closed = false;
                 break;
             }
@@ -197,10 +198,10 @@ bool SVGPathParser::parseSVG(const String& s, bool process)
                     curx = relative ? curx + tox : tox;
                     cury = relative ? cury + toy : toy;
 
-                    svgLineTo(curx, cury);
+                    svgLineTo(narrowPrecisionToFloat(curx), narrowPrecisionToFloat(cury));
                 }
                 else
-                    svgLineTo(tox, toy, !relative);
+                    svgLineTo(narrowPrecisionToFloat(tox), narrowPrecisionToFloat(toy), !relative);
                 break;
             }
             case 'h':
@@ -209,10 +210,10 @@ bool SVGPathParser::parseSVG(const String& s, bool process)
                     return false;
                 if (process) {
                     curx = curx + tox;
-                    svgLineTo(curx, cury);
+                    svgLineTo(narrowPrecisionToFloat(curx), narrowPrecisionToFloat(cury));
                 }
                 else
-                    svgLineToHorizontal(tox, false);
+                    svgLineToHorizontal(narrowPrecisionToFloat(tox), false);
                 break;
             }
             case 'H':
@@ -221,10 +222,10 @@ bool SVGPathParser::parseSVG(const String& s, bool process)
                     return false;
                 if (process) {
                     curx = tox;
-                    svgLineTo(curx, cury);
+                    svgLineTo(narrowPrecisionToFloat(curx), narrowPrecisionToFloat(cury));
                 }
                 else
-                    svgLineToHorizontal(tox);
+                    svgLineToHorizontal(narrowPrecisionToFloat(tox));
                 break;
             }
             case 'v':
@@ -233,10 +234,10 @@ bool SVGPathParser::parseSVG(const String& s, bool process)
                     return false;
                 if (process) {
                     cury = cury + toy;
-                    svgLineTo(curx, cury);
+                    svgLineTo(narrowPrecisionToFloat(curx), narrowPrecisionToFloat(cury));
                 }
                 else
-                    svgLineToVertical(toy, false);
+                    svgLineToVertical(narrowPrecisionToFloat(toy), false);
                 break;
             }
             case 'V':
@@ -245,10 +246,10 @@ bool SVGPathParser::parseSVG(const String& s, bool process)
                     return false;
                 if (process) {
                     cury = toy;
-                    svgLineTo(curx, cury);
+                    svgLineTo(narrowPrecisionToFloat(curx), narrowPrecisionToFloat(cury));
                 }
                 else
-                    svgLineToVertical(toy);
+                    svgLineToVertical(narrowPrecisionToFloat(toy));
                 break;
             }
             case 'z':
@@ -280,7 +281,8 @@ bool SVGPathParser::parseSVG(const String& s, bool process)
                     px3 = relative ? curx + tox : tox;
                     py3 = relative ? cury + toy : toy;
 
-                    svgCurveToCubic(px1, py1, px2, py2, px3, py3);
+                    svgCurveToCubic(narrowPrecisionToFloat(px1), narrowPrecisionToFloat(py1), narrowPrecisionToFloat(px2), 
+                                    narrowPrecisionToFloat(py2), narrowPrecisionToFloat(px3), narrowPrecisionToFloat(py3));
 
                     contrlx = relative ? curx + x2 : x2;
                     contrly = relative ? cury + y2 : y2;
@@ -288,7 +290,8 @@ bool SVGPathParser::parseSVG(const String& s, bool process)
                     cury = relative ? cury + toy : toy;
                 }
                 else
-                    svgCurveToCubic(x1, y1, x2, y2, tox, toy, !relative);
+                    svgCurveToCubic(narrowPrecisionToFloat(x1), narrowPrecisionToFloat(y1), narrowPrecisionToFloat(x2),
+                                    narrowPrecisionToFloat(y2), narrowPrecisionToFloat(tox), narrowPrecisionToFloat(toy), !relative);
 
                 break;
             }
@@ -314,7 +317,8 @@ bool SVGPathParser::parseSVG(const String& s, bool process)
                     px3 = relative ? curx + tox : tox;
                     py3 = relative ? cury + toy : toy;
 
-                    svgCurveToCubic(px1, py1, px2, py2, px3, py3);
+                    svgCurveToCubic(narrowPrecisionToFloat(px1), narrowPrecisionToFloat(py1), narrowPrecisionToFloat(px2),
+                                    narrowPrecisionToFloat(py2), narrowPrecisionToFloat(px3), narrowPrecisionToFloat(py3));
 
                     contrlx = relative ? curx + x2 : x2;
                     contrly = relative ? cury + y2 : y2;
@@ -322,7 +326,8 @@ bool SVGPathParser::parseSVG(const String& s, bool process)
                     cury = relative ? cury + toy : toy;
                 }
                 else
-                    svgCurveToCubicSmooth(x2, y2, tox, toy, !relative);
+                    svgCurveToCubicSmooth(narrowPrecisionToFloat(x2), narrowPrecisionToFloat(y2), 
+                                          narrowPrecisionToFloat(tox), narrowPrecisionToFloat(toy), !relative);
                 break;
             }
             case 'q':
@@ -341,7 +346,8 @@ bool SVGPathParser::parseSVG(const String& s, bool process)
                     px3 = relative ? curx + tox : tox;
                     py3 = relative ? cury + toy : toy;
 
-                    svgCurveToCubic(px1, py1, px2, py2, px3, py3);
+                    svgCurveToCubic(narrowPrecisionToFloat(px1), narrowPrecisionToFloat(py1), narrowPrecisionToFloat(px2),
+                                    narrowPrecisionToFloat(py2), narrowPrecisionToFloat(px3), narrowPrecisionToFloat(py3));
 
                     contrlx = relative ? curx + x1 : x1;
                     contrly = relative ? cury + y1 : y1;
@@ -349,7 +355,8 @@ bool SVGPathParser::parseSVG(const String& s, bool process)
                     cury = relative ? cury + toy : toy;
                 }
                 else
-                    svgCurveToQuadratic(x1, y1, tox, toy, !relative);
+                    svgCurveToQuadratic(narrowPrecisionToFloat(x1), narrowPrecisionToFloat(y1),
+                                        narrowPrecisionToFloat(tox), narrowPrecisionToFloat(toy), !relative);
                 break;
             }
             case 't':
@@ -375,7 +382,8 @@ bool SVGPathParser::parseSVG(const String& s, bool process)
                     px3 = relative ? curx + tox : tox;
                     py3 = relative ? cury + toy : toy;
 
-                    svgCurveToCubic(px1, py1, px2, py2, px3, py3);
+                    svgCurveToCubic(narrowPrecisionToFloat(px1), narrowPrecisionToFloat(py1), narrowPrecisionToFloat(px2),
+                                    narrowPrecisionToFloat(py2), narrowPrecisionToFloat(px3), narrowPrecisionToFloat(py3));
 
                     contrlx = xc;
                     contrly = yc;
@@ -383,7 +391,7 @@ bool SVGPathParser::parseSVG(const String& s, bool process)
                     cury = relative ? cury + toy : toy;
                 }
                 else
-                    svgCurveToQuadraticSmooth(tox, toy, !relative);
+                    svgCurveToQuadraticSmooth(narrowPrecisionToFloat(tox), narrowPrecisionToFloat(toy), !relative);
                 break;
             }
             case 'a':
@@ -409,7 +417,8 @@ bool SVGPathParser::parseSVG(const String& s, bool process)
                 if (process)
                     calculateArc(relative, curx, cury, angle, tox, toy, rx, ry, largeArc, sweep);
                 else
-                    svgArcTo(tox, toy, rx, ry, angle, largeArc, sweep, !relative);
+                    svgArcTo(narrowPrecisionToFloat(tox), narrowPrecisionToFloat(toy), narrowPrecisionToFloat(rx), narrowPrecisionToFloat(ry),
+                             narrowPrecisionToFloat(angle), largeArc, sweep, !relative);
                 break;
             }
             default:
@@ -566,7 +575,9 @@ void SVGPathParser::calculateArc(bool relative, double& curx, double& cury, doub
         x2 = x3 + t * sin(_th1);
         y2 = y3 - t * cos(_th1);
 
-        svgCurveToCubic(a00 * x1 + a01 * y1, a10 * x1 + a11 * y1, a00 * x2 + a01 * y2, a10 * x2 + a11 * y2, a00 * x3 + a01 * y3, a10 * x3 + a11 * y3);
+        svgCurveToCubic(narrowPrecisionToFloat(a00 * x1 + a01 * y1), narrowPrecisionToFloat(a10 * x1 + a11 * y1),
+                        narrowPrecisionToFloat(a00 * x2 + a01 * y2), narrowPrecisionToFloat(a10 * x2 + a11 * y2),
+                        narrowPrecisionToFloat(a00 * x3 + a01 * y3), narrowPrecisionToFloat(a10 * x3 + a11 * y3));
     }
 
     if (!relative)
@@ -580,27 +591,27 @@ void SVGPathParser::calculateArc(bool relative, double& curx, double& cury, doub
         cury += y;    
 }
 
-void SVGPathParser::svgLineToHorizontal(double, bool)
+void SVGPathParser::svgLineToHorizontal(float, bool)
 {
 }
 
-void SVGPathParser::svgLineToVertical(double, bool)
+void SVGPathParser::svgLineToVertical(float, bool)
 {
 }
 
-void SVGPathParser::svgCurveToCubicSmooth(double, double, double, double, bool)
+void SVGPathParser::svgCurveToCubicSmooth(float, float, float, float, bool)
 {
 }
 
-void SVGPathParser::svgCurveToQuadratic(double, double, double, double, bool)
+void SVGPathParser::svgCurveToQuadratic(float, float, float, float, bool)
 {
 }
 
-void SVGPathParser::svgCurveToQuadraticSmooth(double, double, bool)
+void SVGPathParser::svgCurveToQuadraticSmooth(float, float, bool)
 {
 }
 
-void SVGPathParser::svgArcTo(double, double, double, double, double, bool, bool, bool)
+void SVGPathParser::svgArcTo(float, float, float, float, float, bool, bool, bool)
 {
 } 
 
index 4ce40251b00614476fbb47bc79bcb8ca51d1ec64..f9c1cdaa433f0faaf0827769b306dc538868f49f 100644 (file)
@@ -105,15 +105,15 @@ namespace WebCore
         bool parseSVG(const String& d, bool process = false);
 
     protected:
-        virtual void svgMoveTo(double x1, double y1, bool closed, bool abs = true) = 0;
-        virtual void svgLineTo(double x1, double y1, bool abs = true) = 0;
-        virtual void svgLineToHorizontal(double x, bool abs = true);
-        virtual void svgLineToVertical(double y, bool abs = true);
-        virtual void svgCurveToCubic(double x1, double y1, double x2, double y2, double x, double y, bool abs = true) = 0;
-        virtual void svgCurveToCubicSmooth(double x, double y, double x2, double y2, bool abs = true);
-        virtual void svgCurveToQuadratic(double x, double y, double x1, double y1, bool abs = true);
-        virtual void svgCurveToQuadraticSmooth(double x, double y, bool abs = true);
-        virtual void svgArcTo(double x, double y, double r1, double r2, double angle, bool largeArcFlag, bool sweepFlag, bool abs = true);
+        virtual void svgMoveTo(float x1, float y1, bool closed, bool abs = true) = 0;
+        virtual void svgLineTo(float x1, float y1, bool abs = true) = 0;
+        virtual void svgLineToHorizontal(float x, bool abs = true);
+        virtual void svgLineToVertical(float y, bool abs = true);
+        virtual void svgCurveToCubic(float x1, float y1, float x2, float y2, float x, float y, bool abs = true) = 0;
+        virtual void svgCurveToCubicSmooth(float x, float y, float x2, float y2, bool abs = true);
+        virtual void svgCurveToQuadratic(float x, float y, float x1, float y1, bool abs = true);
+        virtual void svgCurveToQuadraticSmooth(float x, float y, bool abs = true);
+        virtual void svgArcTo(float x, float y, float r1, float r2, float angle, bool largeArcFlag, bool sweepFlag, bool abs = true);
         virtual void svgClosePath() = 0;
     private:
         void calculateArc(bool relative, double& curx, double& cury, double angle, double x, double y, double r1, double r2, bool largeArcFlag, bool sweepFlag);
index c8f3cb74bc8c733927da1129e7db32dc673c7765..ce0f23f8e0cb28385defbf987b1210730821f224 100644 (file)
@@ -47,7 +47,7 @@ SVGPathElement::SVGPathElement(const QualifiedName& tagName, Document* doc)
     , SVGLangSpace()
     , SVGExternalResourcesRequired()
     , SVGPathParser()
-    , m_pathLength(0.0)
+    , m_pathLength(0.0f)
 {
 }
 
@@ -55,22 +55,22 @@ SVGPathElement::~SVGPathElement()
 {
 }
 
-ANIMATED_PROPERTY_DEFINITIONS(SVGPathElement, double, Number, number, PathLength, pathLength, SVGNames::pathLengthAttr.localName(), m_pathLength)
+ANIMATED_PROPERTY_DEFINITIONS(SVGPathElement, float, Number, number, PathLength, pathLength, SVGNames::pathLengthAttr.localName(), m_pathLength)
 
-double SVGPathElement::getTotalLength()
+float SVGPathElement::getTotalLength()
 {
     // FIXME: this may wish to use the pathSegList instead of the pathdata if that's cheaper to build (or cached)
     return toPathData().length();
 }
 
-FloatPoint SVGPathElement::getPointAtLength(double length)
+FloatPoint SVGPathElement::getPointAtLength(float length)
 {
     // FIXME: this may wish to use the pathSegList instead of the pathdata if that's cheaper to build (or cached)
     bool ok = false;
     return toPathData().pointAtLength(length, ok);
 }
 
-unsigned long SVGPathElement::getPathSegAtLength(double length)
+unsigned long SVGPathElement::getPathSegAtLength(float length)
 {
     return pathSegList()->getPathSegAtLength(length);
 }
@@ -80,97 +80,97 @@ SVGPathSegClosePath* SVGPathElement::createSVGPathSegClosePath()
     return new SVGPathSegClosePath();
 }
 
-SVGPathSegMovetoAbs* SVGPathElement::createSVGPathSegMovetoAbs(double x, double y)
+SVGPathSegMovetoAbs* SVGPathElement::createSVGPathSegMovetoAbs(float x, float y)
 {
     return new SVGPathSegMovetoAbs(x, y);
 }
 
-SVGPathSegMovetoRel* SVGPathElement::createSVGPathSegMovetoRel(double x, double y)
+SVGPathSegMovetoRel* SVGPathElement::createSVGPathSegMovetoRel(float x, float y)
 {
     return new SVGPathSegMovetoRel(x, y);
 }
 
-SVGPathSegLinetoAbs* SVGPathElement::createSVGPathSegLinetoAbs(double x, double y)
+SVGPathSegLinetoAbs* SVGPathElement::createSVGPathSegLinetoAbs(float x, float y)
 {
     return new SVGPathSegLinetoAbs(x, y);
 }
 
-SVGPathSegLinetoRel* SVGPathElement::createSVGPathSegLinetoRel(double x, double y)
+SVGPathSegLinetoRel* SVGPathElement::createSVGPathSegLinetoRel(float x, float y)
 {
     return new SVGPathSegLinetoRel(x, y);
 }
 
-SVGPathSegCurvetoCubicAbs* SVGPathElement::createSVGPathSegCurvetoCubicAbs(double x, double y, double x1, double y1, double x2, double y2)
+SVGPathSegCurvetoCubicAbs* SVGPathElement::createSVGPathSegCurvetoCubicAbs(float x, float y, float x1, float y1, float x2, float y2)
 {
     return new SVGPathSegCurvetoCubicAbs(x, y, x1, y1, x2, y2);
 }
 
-SVGPathSegCurvetoCubicRel* SVGPathElement::createSVGPathSegCurvetoCubicRel(double x, double y, double x1, double y1, double x2, double y2)
+SVGPathSegCurvetoCubicRel* SVGPathElement::createSVGPathSegCurvetoCubicRel(float x, float y, float x1, float y1, float x2, float y2)
 {
     return new SVGPathSegCurvetoCubicRel(x, y, x1, y1, x2, y2);
 }
 
-SVGPathSegCurvetoQuadraticAbs* SVGPathElement::createSVGPathSegCurvetoQuadraticAbs(double x, double y, double x1, double y1)
+SVGPathSegCurvetoQuadraticAbs* SVGPathElement::createSVGPathSegCurvetoQuadraticAbs(float x, float y, float x1, float y1)
 {
     return new SVGPathSegCurvetoQuadraticAbs(x, y, x1, y1);
 }
 
-SVGPathSegCurvetoQuadraticRel* SVGPathElement::createSVGPathSegCurvetoQuadraticRel(double x, double y, double x1, double y1)
+SVGPathSegCurvetoQuadraticRel* SVGPathElement::createSVGPathSegCurvetoQuadraticRel(float x, float y, float x1, float y1)
 {
     return new SVGPathSegCurvetoQuadraticRel(x, y, x1, y1);
 }
 
-SVGPathSegArcAbs* SVGPathElement::createSVGPathSegArcAbs(double x, double y, double r1, double r2, double angle, bool largeArcFlag, bool sweepFlag)
+SVGPathSegArcAbs* SVGPathElement::createSVGPathSegArcAbs(float x, float y, float r1, float r2, float angle, bool largeArcFlag, bool sweepFlag)
 {
     return new SVGPathSegArcAbs(x, y, r1, r2, angle, largeArcFlag, sweepFlag);
 }
 
-SVGPathSegArcRel* SVGPathElement::createSVGPathSegArcRel(double x, double y, double r1, double r2, double angle, bool largeArcFlag, bool sweepFlag)
+SVGPathSegArcRel* SVGPathElement::createSVGPathSegArcRel(float x, float y, float r1, float r2, float angle, bool largeArcFlag, bool sweepFlag)
 {
     return new SVGPathSegArcRel(x, y, r1, r2, angle, largeArcFlag, sweepFlag);
 }
 
-SVGPathSegLinetoHorizontalAbs* SVGPathElement::createSVGPathSegLinetoHorizontalAbs(double x)
+SVGPathSegLinetoHorizontalAbs* SVGPathElement::createSVGPathSegLinetoHorizontalAbs(float x)
 {
     return new SVGPathSegLinetoHorizontalAbs(x);
 }
 
-SVGPathSegLinetoHorizontalRel* SVGPathElement::createSVGPathSegLinetoHorizontalRel(double x)
+SVGPathSegLinetoHorizontalRel* SVGPathElement::createSVGPathSegLinetoHorizontalRel(float x)
 {
     return new SVGPathSegLinetoHorizontalRel(x);
 }
 
-SVGPathSegLinetoVerticalAbs* SVGPathElement::createSVGPathSegLinetoVerticalAbs(double y)
+SVGPathSegLinetoVerticalAbs* SVGPathElement::createSVGPathSegLinetoVerticalAbs(float y)
 {
     return new SVGPathSegLinetoVerticalAbs(y);
 }
 
-SVGPathSegLinetoVerticalRel* SVGPathElement::createSVGPathSegLinetoVerticalRel(double y)
+SVGPathSegLinetoVerticalRel* SVGPathElement::createSVGPathSegLinetoVerticalRel(float y)
 {
     return new SVGPathSegLinetoVerticalRel(y);
 }
 
-SVGPathSegCurvetoCubicSmoothAbs* SVGPathElement::createSVGPathSegCurvetoCubicSmoothAbs(double x, double y, double x2, double y2)
+SVGPathSegCurvetoCubicSmoothAbs* SVGPathElement::createSVGPathSegCurvetoCubicSmoothAbs(float x, float y, float x2, float y2)
 {
     return new SVGPathSegCurvetoCubicSmoothAbs(x, y, x2, y2);
 }
 
-SVGPathSegCurvetoCubicSmoothRel* SVGPathElement::createSVGPathSegCurvetoCubicSmoothRel(double x, double y, double x2, double y2)
+SVGPathSegCurvetoCubicSmoothRel* SVGPathElement::createSVGPathSegCurvetoCubicSmoothRel(float x, float y, float x2, float y2)
 {
     return new SVGPathSegCurvetoCubicSmoothRel(x, y, x2, y2);
 }
 
-SVGPathSegCurvetoQuadraticSmoothAbs* SVGPathElement::createSVGPathSegCurvetoQuadraticSmoothAbs(double x, double y)
+SVGPathSegCurvetoQuadraticSmoothAbs* SVGPathElement::createSVGPathSegCurvetoQuadraticSmoothAbs(float x, float y)
 {
     return new SVGPathSegCurvetoQuadraticSmoothAbs(x, y);
 }
 
-SVGPathSegCurvetoQuadraticSmoothRel* SVGPathElement::createSVGPathSegCurvetoQuadraticSmoothRel(double x, double y)
+SVGPathSegCurvetoQuadraticSmoothRel* SVGPathElement::createSVGPathSegCurvetoQuadraticSmoothRel(float x, float y)
 {
     return new SVGPathSegCurvetoQuadraticSmoothRel(x, y);
 }
 
-void SVGPathElement::svgMoveTo(double x1, double y1, bool, bool abs)
+void SVGPathElement::svgMoveTo(float x1, float y1, bool, bool abs)
 {
     ExceptionCode ec = 0;
 
@@ -180,7 +180,7 @@ void SVGPathElement::svgMoveTo(double x1, double y1, bool, bool abs)
         pathSegList()->appendItem(createSVGPathSegMovetoRel(x1, y1), ec);
 }
 
-void SVGPathElement::svgLineTo(double x1, double y1, bool abs)
+void SVGPathElement::svgLineTo(float x1, float y1, bool abs)
 {
     ExceptionCode ec = 0;
 
@@ -190,7 +190,7 @@ void SVGPathElement::svgLineTo(double x1, double y1, bool abs)
         pathSegList()->appendItem(createSVGPathSegLinetoRel(x1, y1), ec);
 }
 
-void SVGPathElement::svgLineToHorizontal(double x, bool abs)
+void SVGPathElement::svgLineToHorizontal(float x, bool abs)
 {
     ExceptionCode ec = 0;
 
@@ -200,7 +200,7 @@ void SVGPathElement::svgLineToHorizontal(double x, bool abs)
         pathSegList()->appendItem(createSVGPathSegLinetoHorizontalRel(x), ec);
 }
 
-void SVGPathElement::svgLineToVertical(double y, bool abs)
+void SVGPathElement::svgLineToVertical(float y, bool abs)
 {
     ExceptionCode ec = 0;
 
@@ -210,7 +210,7 @@ void SVGPathElement::svgLineToVertical(double y, bool abs)
         pathSegList()->appendItem(createSVGPathSegLinetoVerticalRel(y), ec);
 }
 
-void SVGPathElement::svgCurveToCubic(double x1, double y1, double x2, double y2, double x, double y, bool abs)
+void SVGPathElement::svgCurveToCubic(float x1, float y1, float x2, float y2, float x, float y, bool abs)
 {
     ExceptionCode ec = 0;
 
@@ -220,7 +220,7 @@ void SVGPathElement::svgCurveToCubic(double x1, double y1, double x2, double y2,
         pathSegList()->appendItem(createSVGPathSegCurvetoCubicRel(x, y, x1, y1, x2, y2), ec);
 }
 
-void SVGPathElement::svgCurveToCubicSmooth(double x, double y, double x2, double y2, bool abs)
+void SVGPathElement::svgCurveToCubicSmooth(float x, float y, float x2, float y2, bool abs)
 {
     ExceptionCode ec = 0;
 
@@ -230,7 +230,7 @@ void SVGPathElement::svgCurveToCubicSmooth(double x, double y, double x2, double
         pathSegList()->appendItem(createSVGPathSegCurvetoCubicSmoothRel(x2, y2, x, y), ec);
 }
 
-void SVGPathElement::svgCurveToQuadratic(double x, double y, double x1, double y1, bool abs)
+void SVGPathElement::svgCurveToQuadratic(float x, float y, float x1, float y1, bool abs)
 {
     ExceptionCode ec = 0;
 
@@ -240,7 +240,7 @@ void SVGPathElement::svgCurveToQuadratic(double x, double y, double x1, double y
         pathSegList()->appendItem(createSVGPathSegCurvetoQuadraticRel(x1, y1, x, y), ec);
 }
 
-void SVGPathElement::svgCurveToQuadraticSmooth(double x, double y, bool abs)
+void SVGPathElement::svgCurveToQuadraticSmooth(float x, float y, bool abs)
 {
     ExceptionCode ec = 0;
 
@@ -250,7 +250,7 @@ void SVGPathElement::svgCurveToQuadraticSmooth(double x, double y, bool abs)
         pathSegList()->appendItem(createSVGPathSegCurvetoQuadraticSmoothRel(x, y), ec);
 }
 
-void SVGPathElement::svgArcTo(double x, double y, double r1, double r2, double angle, bool largeArcFlag, bool sweepFlag, bool abs)
+void SVGPathElement::svgArcTo(float x, float y, float r1, float r2, float angle, bool largeArcFlag, bool sweepFlag, bool abs)
 {
     ExceptionCode ec = 0;
 
@@ -274,8 +274,8 @@ void SVGPathElement::parseMappedAttribute(MappedAttribute* attr)
         if (!parseSVG(attr->value(), true))
             document()->accessSVGExtensions()->reportError("Problem parsing d=\"" + attr->value() + "\"");
     } else if (attr->name() == SVGNames::pathLengthAttr) {
-        m_pathLength = attr->value().toDouble();
-        if (m_pathLength < 0.0)
+        m_pathLength = attr->value().toFloat();
+        if (m_pathLength < 0.0f)
             document()->accessSVGExtensions()->reportError("A negative value for path attribute <pathLength> is not allowed");
     } else {
         if (SVGTests::parseMappedAttribute(attr))
index 0de0266513eda0a8029ce46e3d859b2838e775a6..509601a7e7f8069408a6a11f3d6c17ff3e892c00 100644 (file)
@@ -32,8 +32,8 @@
 #include "SVGStyledTransformableElement.h"
 #include "SVGTests.h"
 
-namespace WebCore
-{
+namespace WebCore {
+
     class SVGPathSeg;
     class SVGPathSegArcAbs;
     class SVGPathSegArcRel;
@@ -66,29 +66,29 @@ namespace WebCore
         virtual ~SVGPathElement();
         
         virtual bool isValid() const { return SVGTests::isValid(); }
-        double getTotalLength();
-        FloatPoint getPointAtLength(double distance);
-        unsigned long getPathSegAtLength(double distance);
+        float getTotalLength();
+        FloatPoint getPointAtLength(float distance);
+        unsigned long getPathSegAtLength(float distance);
 
         SVGPathSegClosePath* createSVGPathSegClosePath();
-        SVGPathSegMovetoAbs* createSVGPathSegMovetoAbs(double x, double y);
-        SVGPathSegMovetoRel* createSVGPathSegMovetoRel(double x, double y);
-        SVGPathSegLinetoAbs* createSVGPathSegLinetoAbs(double x, double y);
-        SVGPathSegLinetoRel* createSVGPathSegLinetoRel(double x, double y);
-        SVGPathSegCurvetoCubicAbs* createSVGPathSegCurvetoCubicAbs(double x, double y, double x1, double y1, double x2, double y2);
-        SVGPathSegCurvetoCubicRel* createSVGPathSegCurvetoCubicRel(double x, double y, double x1, double y1, double x2, double y2);
-        SVGPathSegCurvetoQuadraticAbs* createSVGPathSegCurvetoQuadraticAbs(double x, double y, double x1, double y1);
-        SVGPathSegCurvetoQuadraticRel* createSVGPathSegCurvetoQuadraticRel(double x, double y, double x1, double y1);
-        SVGPathSegArcAbs* createSVGPathSegArcAbs(double x, double y, double r1, double r2, double angle, bool largeArcFlag, bool sweepFlag);
-        SVGPathSegArcRel* createSVGPathSegArcRel(double x, double y, double r1, double r2, double angle, bool largeArcFlag, bool sweepFlag);
-        SVGPathSegLinetoHorizontalAbs* createSVGPathSegLinetoHorizontalAbs(double x);
-        SVGPathSegLinetoHorizontalRel* createSVGPathSegLinetoHorizontalRel(double x);
-        SVGPathSegLinetoVerticalAbs* createSVGPathSegLinetoVerticalAbs(double y);
-        SVGPathSegLinetoVerticalRel* createSVGPathSegLinetoVerticalRel(double y);
-        SVGPathSegCurvetoCubicSmoothAbs* createSVGPathSegCurvetoCubicSmoothAbs(double x, double y, double x2, double y2);
-        SVGPathSegCurvetoCubicSmoothRel* createSVGPathSegCurvetoCubicSmoothRel(double x, double y, double x2, double y2);
-        SVGPathSegCurvetoQuadraticSmoothAbs* createSVGPathSegCurvetoQuadraticSmoothAbs(double x, double y);
-        SVGPathSegCurvetoQuadraticSmoothRel* createSVGPathSegCurvetoQuadraticSmoothRel(double x, double y);
+        SVGPathSegMovetoAbs* createSVGPathSegMovetoAbs(float x, float y);
+        SVGPathSegMovetoRel* createSVGPathSegMovetoRel(float x, float y);
+        SVGPathSegLinetoAbs* createSVGPathSegLinetoAbs(float x, float y);
+        SVGPathSegLinetoRel* createSVGPathSegLinetoRel(float x, float y);
+        SVGPathSegCurvetoCubicAbs* createSVGPathSegCurvetoCubicAbs(float x, float y, float x1, float y1, float x2, float y2);
+        SVGPathSegCurvetoCubicRel* createSVGPathSegCurvetoCubicRel(float x, float y, float x1, float y1, float x2, float y2);
+        SVGPathSegCurvetoQuadraticAbs* createSVGPathSegCurvetoQuadraticAbs(float x, float y, float x1, float y1);
+        SVGPathSegCurvetoQuadraticRel* createSVGPathSegCurvetoQuadraticRel(float x, float y, float x1, float y1);
+        SVGPathSegArcAbs* createSVGPathSegArcAbs(float x, float y, float r1, float r2, float angle, bool largeArcFlag, bool sweepFlag);
+        SVGPathSegArcRel* createSVGPathSegArcRel(float x, float y, float r1, float r2, float angle, bool largeArcFlag, bool sweepFlag);
+        SVGPathSegLinetoHorizontalAbs* createSVGPathSegLinetoHorizontalAbs(float x);
+        SVGPathSegLinetoHorizontalRel* createSVGPathSegLinetoHorizontalRel(float x);
+        SVGPathSegLinetoVerticalAbs* createSVGPathSegLinetoVerticalAbs(float y);
+        SVGPathSegLinetoVerticalRel* createSVGPathSegLinetoVerticalRel(float y);
+        SVGPathSegCurvetoCubicSmoothAbs* createSVGPathSegCurvetoCubicSmoothAbs(float x, float y, float x2, float y2);
+        SVGPathSegCurvetoCubicSmoothRel* createSVGPathSegCurvetoCubicSmoothRel(float x, float y, float x2, float y2);
+        SVGPathSegCurvetoQuadraticSmoothAbs* createSVGPathSegCurvetoQuadraticSmoothAbs(float x, float y);
+        SVGPathSegCurvetoQuadraticSmoothRel* createSVGPathSegCurvetoQuadraticSmoothRel(float x, float y);
 
         // Derived from: 'SVGAnimatedPathData'
         virtual SVGPathSegList* pathSegList() const;
@@ -111,17 +111,17 @@ namespace WebCore
 
         ANIMATED_PROPERTY_FORWARD_DECLARATIONS(SVGExternalResourcesRequired, bool, ExternalResourcesRequired, externalResourcesRequired)
  
-        ANIMATED_PROPERTY_DECLARATIONS(SVGPathElement, double, double, PathLength, pathLength)
-
-        virtual void svgMoveTo(double x1, double y1, bool closed, bool abs = true);
-        virtual void svgLineTo(double x1, double y1, bool abs = true);
-        virtual void svgLineToHorizontal(double x, bool abs = true);
-        virtual void svgLineToVertical(double y, bool abs = true);
-        virtual void svgCurveToCubic(double x1, double y1, double x2, double y2, double x, double y, bool abs = true);
-        virtual void svgCurveToCubicSmooth(double x, double y, double x2, double y2, bool abs = true);
-        virtual void svgCurveToQuadratic(double x, double y, double x1, double y1, bool abs = true);
-        virtual void svgCurveToQuadraticSmooth(double x, double y, bool abs = true);
-        virtual void svgArcTo(double x, double y, double r1, double r2, double angle, bool largeArcFlag, bool sweepFlag, bool abs = true);
+        ANIMATED_PROPERTY_DECLARATIONS(SVGPathElement, float, float, PathLength, pathLength)
+
+        virtual void svgMoveTo(float x1, float y1, bool closed, bool abs = true);
+        virtual void svgLineTo(float x1, float y1, bool abs = true);
+        virtual void svgLineToHorizontal(float x, bool abs = true);
+        virtual void svgLineToVertical(float y, bool abs = true);
+        virtual void svgCurveToCubic(float x1, float y1, float x2, float y2, float x, float y, bool abs = true);
+        virtual void svgCurveToCubicSmooth(float x, float y, float x2, float y2, bool abs = true);
+        virtual void svgCurveToQuadratic(float x, float y, float x1, float y1, bool abs = true);
+        virtual void svgCurveToQuadraticSmooth(float x, float y, bool abs = true);
+        virtual void svgArcTo(float x, float y, float r1, float r2, float angle, bool largeArcFlag, bool sweepFlag, bool abs = true);
         virtual void svgClosePath();
     };
 
index 625e57b7adc5b13b1c1acf21e55ac10561dadfea..e722a1144958d86797c831ec50c29f3dffb03ece 100644 (file)
@@ -29,7 +29,7 @@
 
 namespace WebCore {
 
-SVGPathSegArcAbs::SVGPathSegArcAbs(double x, double y, double r1, double r2, double angle, bool largeArcFlag, bool sweepFlag)
+SVGPathSegArcAbs::SVGPathSegArcAbs(float x, float y, float r1, float r2, float angle, bool largeArcFlag, bool sweepFlag)
     : SVGPathSeg()
     , m_x(x)
     , m_y(y)
@@ -45,52 +45,52 @@ SVGPathSegArcAbs::~SVGPathSegArcAbs()
 {
 }
 
-void SVGPathSegArcAbs::setX(double x)
+void SVGPathSegArcAbs::setX(float x)
 {
     m_x = x;
 }
 
-double SVGPathSegArcAbs::x() const
+float SVGPathSegArcAbs::x() const
 {
     return m_x;
 }
 
-void SVGPathSegArcAbs::setY(double y)
+void SVGPathSegArcAbs::setY(float y)
 {
     m_y = y;
 }
 
-double SVGPathSegArcAbs::y() const
+float SVGPathSegArcAbs::y() const
 {
     return m_y;
 }
 
-void SVGPathSegArcAbs::setR1(double r1)
+void SVGPathSegArcAbs::setR1(float r1)
 {
     m_r1 = r1;
 }
 
-double SVGPathSegArcAbs::r1() const
+float SVGPathSegArcAbs::r1() const
 {
     return m_r1;
 }
 
-void SVGPathSegArcAbs::setR2(double r2)
+void SVGPathSegArcAbs::setR2(float r2)
 {
     m_r2 = r2;
 }
 
-double SVGPathSegArcAbs::r2() const
+float SVGPathSegArcAbs::r2() const
 {
     return m_r2;
 }
 
-void SVGPathSegArcAbs::setAngle(double angle)
+void SVGPathSegArcAbs::setAngle(float angle)
 {
     m_angle = angle;
 }
 
-double SVGPathSegArcAbs::angle() const
+float SVGPathSegArcAbs::angle() const
 {
     return m_angle;
 }
@@ -117,7 +117,7 @@ bool SVGPathSegArcAbs::sweepFlag() const
 
 
 
-SVGPathSegArcRel::SVGPathSegArcRel(double x, double y, double r1, double r2, double angle, bool largeArcFlag, bool sweepFlag)
+SVGPathSegArcRel::SVGPathSegArcRel(float x, float y, float r1, float r2, float angle, bool largeArcFlag, bool sweepFlag)
     : SVGPathSeg()
     , m_x(x)
     , m_y(y)
@@ -133,52 +133,52 @@ SVGPathSegArcRel::~SVGPathSegArcRel()
 {
 }
 
-void SVGPathSegArcRel::setX(double x)
+void SVGPathSegArcRel::setX(float x)
 {
     m_x = x;
 }
 
-double SVGPathSegArcRel::x() const
+float SVGPathSegArcRel::x() const
 {
     return m_x;
 }
 
-void SVGPathSegArcRel::setY(double y)
+void SVGPathSegArcRel::setY(float y)
 {
     m_y = y;
 }
 
-double SVGPathSegArcRel::y() const
+float SVGPathSegArcRel::y() const
 {
     return m_y;
 }
 
-void SVGPathSegArcRel::setR1(double r1)
+void SVGPathSegArcRel::setR1(float r1)
 {
     m_r1 = r1;
 }
 
-double SVGPathSegArcRel::r1() const
+float SVGPathSegArcRel::r1() const
 {
     return m_r1;
 }
 
-void SVGPathSegArcRel::setR2(double r2)
+void SVGPathSegArcRel::setR2(float r2)
 {
     m_r2 = r2;
 }
 
-double SVGPathSegArcRel::r2() const
+float SVGPathSegArcRel::r2() const
 {
     return m_r2;
 }
 
-void SVGPathSegArcRel::setAngle(double angle)
+void SVGPathSegArcRel::setAngle(float angle)
 {
     m_angle = angle;
 }
 
-double SVGPathSegArcRel::angle() const
+float SVGPathSegArcRel::angle() const
 {
     return m_angle;
 }
index e7e01b20020373892abc6ce25fc2c006f8e61d5e..d71e1b7be5a210beed7b5a06c7365afb1c778e65 100644 (file)
 
 #include "SVGPathSeg.h"
 
-namespace WebCore
-{
-    class SVGPathSegArcAbs : public SVGPathSeg
-    {
+namespace WebCore {
+
+    class SVGPathSegArcAbs : public SVGPathSeg {
     public:
-        SVGPathSegArcAbs(double x, double y, double r1, double r2, double angle, bool largeArcFlag, bool sweepFlag);
+        SVGPathSegArcAbs(float x, float y, float r1, float r2, float angle, bool largeArcFlag, bool sweepFlag);
         virtual ~SVGPathSegArcAbs();
 
         virtual unsigned short pathSegType() const { return PATHSEG_ARC_ABS; }
         virtual String pathSegTypeAsLetter() const { return "A"; }
         virtual String toString() const { return String::format("A %.6lg %.6lg %.6lg %d %d %.6lg %.6lg", m_r1, m_r2, m_angle, m_largeArcFlag, m_sweepFlag, m_x, m_y); }
 
-        void setX(double x);
-        double x() const;
+        void setX(float x);
+        float x() const;
 
-        void setY(double y);
-        double y() const;
+        void setY(float y);
+        float y() const;
 
-        void setR1(double r1);
-        double r1() const;
+        void setR1(float r1);
+        float r1() const;
 
-        void setR2(double r2);
-        double r2() const;
+        void setR2(float r2);
+        float r2() const;
 
-        void setAngle(double angle);
-        double angle() const;
+        void setAngle(float angle);
+        float angle() const;
 
         void setLargeArcFlag(bool largeArcFlag);
         bool largeArcFlag() const;
@@ -61,40 +60,39 @@ namespace WebCore
         bool sweepFlag() const;
 
     private:
-        double m_x;
-        double m_y;
-        double m_r1;
-        double m_r2;
-        double m_angle;
+        float m_x;
+        float m_y;
+        float m_r1;
+        float m_r2;
+        float m_angle;
 
         bool m_largeArcFlag    : 1;
         bool m_sweepFlag : 1;
     };
 
-    class SVGPathSegArcRel : public SVGPathSeg
-    {
+    class SVGPathSegArcRel : public SVGPathSeg {
     public:
-        SVGPathSegArcRel(double x, double y, double r1, double r2, double angle, bool largeArcFlag, bool sweepFlag);
+        SVGPathSegArcRel(float x, float y, float r1, float r2, float angle, bool largeArcFlag, bool sweepFlag);
         virtual ~SVGPathSegArcRel();
 
         virtual unsigned short pathSegType() const { return PATHSEG_ARC_REL; }
         virtual String pathSegTypeAsLetter() const { return "a"; }
         virtual String toString() const { return String::format("a %.6lg %.6lg %.6lg %d %d %.6lg %.6lg", m_r1, m_r2, m_angle, m_largeArcFlag, m_sweepFlag, m_x, m_y); }
 
-        void setX(double x);
-        double x() const;
+        void setX(float x);
+        float x() const;
 
-        void setY(double y);
-        double y() const;
+        void setY(float y);
+        float y() const;
 
-        void setR1(double r1);
-        double r1() const;
+        void setR1(float r1);
+        float r1() const;
 
-        void setR2(double r2);
-        double r2() const;
+        void setR2(float r2);
+        float r2() const;
 
-        void setAngle(double angle);
-        double angle() const;
+        void setAngle(float angle);
+        float angle() const;
 
         void setLargeArcFlag(bool largeArcFlag);
         bool largeArcFlag() const;
@@ -103,11 +101,11 @@ namespace WebCore
         bool sweepFlag() const;
 
     private:
-        double m_x;
-        double m_y;
-        double m_r1;
-        double m_r2;
-        double m_angle;
+        float m_x;
+        float m_y;
+        float m_r1;
+        float m_r2;
+        float m_angle;
 
         bool m_largeArcFlag : 1;
         bool m_sweepFlag : 1;
index b1d1f4fddd0b90f04b7a8859d79560ef2e9b77e5..fa184e9041950ce096c221eba5df6afbf001322f 100644 (file)
@@ -29,7 +29,7 @@
 
 namespace WebCore {
 
-SVGPathSegCurvetoCubicAbs::SVGPathSegCurvetoCubicAbs(double x, double y, double x1, double y1, double x2, double y2)
+SVGPathSegCurvetoCubicAbs::SVGPathSegCurvetoCubicAbs(float x, float y, float x1, float y1, float x2, float y2)
     : SVGPathSeg()
     , m_x(x)
     , m_y(y)
@@ -44,62 +44,62 @@ SVGPathSegCurvetoCubicAbs::~SVGPathSegCurvetoCubicAbs()
 {
 }
 
-void SVGPathSegCurvetoCubicAbs::setX(double x)
+void SVGPathSegCurvetoCubicAbs::setX(float x)
 {
     m_x = x;
 }
 
-double SVGPathSegCurvetoCubicAbs::x() const
+float SVGPathSegCurvetoCubicAbs::x() const
 {
     return m_x;
 }
 
-void SVGPathSegCurvetoCubicAbs::setY(double y)
+void SVGPathSegCurvetoCubicAbs::setY(float y)
 {
     m_y = y;
 }
 
-double SVGPathSegCurvetoCubicAbs::y() const
+float SVGPathSegCurvetoCubicAbs::y() const
 {
     return m_y;
 }
 
-void SVGPathSegCurvetoCubicAbs::setX1(double x1)
+void SVGPathSegCurvetoCubicAbs::setX1(float x1)
 {
     m_x1 = x1;
 }
 
-double SVGPathSegCurvetoCubicAbs::x1() const
+float SVGPathSegCurvetoCubicAbs::x1() const
 {
     return m_x1;
 }
 
-void SVGPathSegCurvetoCubicAbs::setY1(double y1)
+void SVGPathSegCurvetoCubicAbs::setY1(float y1)
 {
     m_y1 = y1;
 }
 
-double SVGPathSegCurvetoCubicAbs::y1() const
+float SVGPathSegCurvetoCubicAbs::y1() const
 {
     return m_y1;
 }
 
-void SVGPathSegCurvetoCubicAbs::setX2(double x2)
+void SVGPathSegCurvetoCubicAbs::setX2(float x2)
 {
     m_x2 = x2;
 }
 
-double SVGPathSegCurvetoCubicAbs::x2() const
+float SVGPathSegCurvetoCubicAbs::x2() const
 {
     return m_x2;
 }
 
-void SVGPathSegCurvetoCubicAbs::setY2(double y2)
+void SVGPathSegCurvetoCubicAbs::setY2(float y2)
 {
     m_y2 = y2;
 }
 
-double SVGPathSegCurvetoCubicAbs::y2() const
+float SVGPathSegCurvetoCubicAbs::y2() const
 {
     return m_y2;
 }
@@ -107,7 +107,7 @@ double SVGPathSegCurvetoCubicAbs::y2() const
 
 
 
-SVGPathSegCurvetoCubicRel::SVGPathSegCurvetoCubicRel(double x, double y, double x1, double y1, double x2, double y2)
+SVGPathSegCurvetoCubicRel::SVGPathSegCurvetoCubicRel(float x, float y, float x1, float y1, float x2, float y2)
     : SVGPathSeg()
     , m_x(x)
     , m_y(y)
@@ -122,62 +122,62 @@ SVGPathSegCurvetoCubicRel::~SVGPathSegCurvetoCubicRel()
 {
 }
 
-void SVGPathSegCurvetoCubicRel::setX(double x)
+void SVGPathSegCurvetoCubicRel::setX(float x)
 {
     m_x = x;
 }
 
-double SVGPathSegCurvetoCubicRel::x() const
+float SVGPathSegCurvetoCubicRel::x() const
 {
     return m_x;
 }
 
-void SVGPathSegCurvetoCubicRel::setY(double y)
+void SVGPathSegCurvetoCubicRel::setY(float y)
 {
     m_y = y;
 }
 
-double SVGPathSegCurvetoCubicRel::y() const
+float SVGPathSegCurvetoCubicRel::y() const
 {
     return m_y;
 }
 
-void SVGPathSegCurvetoCubicRel::setX1(double x1)
+void SVGPathSegCurvetoCubicRel::setX1(float x1)
 {
     m_x1 = x1;
 }
 
-double SVGPathSegCurvetoCubicRel::x1() const
+float SVGPathSegCurvetoCubicRel::x1() const
 {
     return m_x1;
 }
 
-void SVGPathSegCurvetoCubicRel::setY1(double y1)
+void SVGPathSegCurvetoCubicRel::setY1(float y1)
 {
     m_y1 = y1;
 }
 
-double SVGPathSegCurvetoCubicRel::y1() const
+float SVGPathSegCurvetoCubicRel::y1() const
 {
     return m_y1;
 }
 
-void SVGPathSegCurvetoCubicRel::setX2(double x2)
+void SVGPathSegCurvetoCubicRel::setX2(float x2)
 {
     m_x2 = x2;
 }
 
-double SVGPathSegCurvetoCubicRel::x2() const
+float SVGPathSegCurvetoCubicRel::x2() const
 {
     return m_x2;
 }
 
-void SVGPathSegCurvetoCubicRel::setY2(double y2)
+void SVGPathSegCurvetoCubicRel::setY2(float y2)
 {
     m_y2 = y2;
 }
 
-double SVGPathSegCurvetoCubicRel::y2() const
+float SVGPathSegCurvetoCubicRel::y2() const
 {
     return m_y2;
 }
index 0154fbe4d088503fe4271c68ba9035b0fcf79a14..81c060fc7767d2aef8e589e17ed164f822c47134 100644 (file)
 
 #include "SVGPathSeg.h"
 
-namespace WebCore
-{
-    class SVGPathSegCurvetoCubicAbs : public SVGPathSeg 
-    { 
+namespace WebCore {
+    class SVGPathSegCurvetoCubicAbs : public SVGPathSeg { 
     public:
-        SVGPathSegCurvetoCubicAbs(double x, double y, double x1, double y1, double x2, double y2);
+        SVGPathSegCurvetoCubicAbs(float x, float y, float x1, float y1, float x2, float y2);
         virtual ~SVGPathSegCurvetoCubicAbs();
 
         virtual unsigned short pathSegType() const { return PATHSEG_CURVETO_CUBIC_ABS; }
         virtual String pathSegTypeAsLetter() const { return "C"; }
         virtual String toString() const { return String::format("C %.6lg %.6lg %.6lg %.6lg %.6lg %.6lg", m_x1, m_y1, m_x2, m_y2, m_x, m_y); }
 
-        void setX(double);
-        double x() const;
+        void setX(float);
+        float x() const;
 
-        void setY(double);
-        double y() const;
+        void setY(float);
+        float y() const;
 
-        void setX1(double);
-        double x1() const;
+        void setX1(float);
+        float x1() const;
 
-        void setY1(double);
-        double y1() const;
+        void setY1(float);
+        float y1() const;
 
-        void setX2(double);
-        double x2() const;
+        void setX2(float);
+        float x2() const;
 
-        void setY2(double);
-        double y2() const;
+        void setY2(float);
+        float y2() const;
 
     private:
-        double m_x;
-        double m_y;
-        double m_x1;
-        double m_y1;
-        double m_x2;
-        double m_y2;
+        float m_x;
+        float m_y;
+        float m_x1;
+        float m_y1;
+        float m_x2;
+        float m_y2;
     };
 
-    class SVGPathSegCurvetoCubicRel : public SVGPathSeg 
-    { 
+    class SVGPathSegCurvetoCubicRel : public SVGPathSeg { 
     public:
-        SVGPathSegCurvetoCubicRel(double x, double y, double x1, double y1, double x2, double y2);
+        SVGPathSegCurvetoCubicRel(float x, float y, float x1, float y1, float x2, float y2);
         virtual ~SVGPathSegCurvetoCubicRel();
 
         virtual unsigned short pathSegType() const { return PATHSEG_CURVETO_CUBIC_REL; }
         virtual String pathSegTypeAsLetter() const { return "c"; }
         virtual String toString() const { return String::format("c %.6lg %.6lg %.6lg %.6lg %.6lg %.6lg", m_x1, m_y1, m_x2, m_y2, m_x, m_y); }
 
-        void setX(double);
-        double x() const;
+        void setX(float);
+        float x() const;
 
-        void setY(double);
-        double y() const;
+        void setY(float);
+        float y() const;
 
-        void setX1(double);
-        double x1() const;
+        void setX1(float);
+        float x1() const;
 
-        void setY1(double);
-        double y1() const;
+        void setY1(float);
+        float y1() const;
 
-        void setX2(double);
-        double x2() const;
+        void setX2(float);
+        float x2() const;
 
-        void setY2(double);
-        double y2() const;
+        void setY2(float);
+        float y2() const;
 
     private:
-        double m_x;
-        double m_y;
-        double m_x1;
-        double m_y1;
-        double m_x2;
-        double m_y2;
+        float m_x;
+        float m_y;
+        float m_x1;
+        float m_y1;
+        float m_x2;
+        float m_y2;
     };
 
 } // namespace WebCore
index 22b5b07fa74a0fb3fbf829e569e907a0559350f3..47f91ad48c9c9093a341763c8bc2c25f6dcac26c 100644 (file)
@@ -28,7 +28,7 @@
 
 namespace WebCore {
 
-SVGPathSegCurvetoCubicSmoothAbs::SVGPathSegCurvetoCubicSmoothAbs(double x, double y, double x2, double y2)
+SVGPathSegCurvetoCubicSmoothAbs::SVGPathSegCurvetoCubicSmoothAbs(float x, float y, float x2, float y2)
     : SVGPathSeg()
     , m_x(x)
     , m_y(y)
@@ -41,49 +41,49 @@ SVGPathSegCurvetoCubicSmoothAbs::~SVGPathSegCurvetoCubicSmoothAbs()
 {
 }
 
-void SVGPathSegCurvetoCubicSmoothAbs::setX(double x)
+void SVGPathSegCurvetoCubicSmoothAbs::setX(float x)
 {
     m_x = x;
 }
 
-double SVGPathSegCurvetoCubicSmoothAbs::x() const
+float SVGPathSegCurvetoCubicSmoothAbs::x() const
 {
     return m_x;
 }
 
-void SVGPathSegCurvetoCubicSmoothAbs::setY(double y)
+void SVGPathSegCurvetoCubicSmoothAbs::setY(float y)
 {
     m_y = y;
 }
 
-double SVGPathSegCurvetoCubicSmoothAbs::y() const
+float SVGPathSegCurvetoCubicSmoothAbs::y() const
 {
     return m_y;
 }
 
-void SVGPathSegCurvetoCubicSmoothAbs::setX2(double x2)
+void SVGPathSegCurvetoCubicSmoothAbs::setX2(float x2)
 {
     m_x2 = x2;
 }
 
-double SVGPathSegCurvetoCubicSmoothAbs::x2() const
+float SVGPathSegCurvetoCubicSmoothAbs::x2() const
 {
     return m_x2;
 }
 
-void SVGPathSegCurvetoCubicSmoothAbs::setY2(double y2)
+void SVGPathSegCurvetoCubicSmoothAbs::setY2(float y2)
 {
     m_y2 = y2;
 }
 
-double SVGPathSegCurvetoCubicSmoothAbs::y2() const
+float SVGPathSegCurvetoCubicSmoothAbs::y2() const
 {
     return m_y2;
 }
 
 
 
-SVGPathSegCurvetoCubicSmoothRel::SVGPathSegCurvetoCubicSmoothRel(double x, double y, double x2, double y2)
+SVGPathSegCurvetoCubicSmoothRel::SVGPathSegCurvetoCubicSmoothRel(float x, float y, float x2, float y2)
     : SVGPathSeg()
     , m_x(x)
     , m_y(y)
@@ -96,42 +96,42 @@ SVGPathSegCurvetoCubicSmoothRel::~SVGPathSegCurvetoCubicSmoothRel()
 {
 }
 
-void SVGPathSegCurvetoCubicSmoothRel::setX(double x)
+void SVGPathSegCurvetoCubicSmoothRel::setX(float x)
 {
     m_x = x;
 }
 
-double SVGPathSegCurvetoCubicSmoothRel::x() const
+float SVGPathSegCurvetoCubicSmoothRel::x() const
 {
     return m_x;
 }
 
-void SVGPathSegCurvetoCubicSmoothRel::setY(double y)
+void SVGPathSegCurvetoCubicSmoothRel::setY(float y)
 {
     m_y = y;
 }
 
-double SVGPathSegCurvetoCubicSmoothRel::y() const
+float SVGPathSegCurvetoCubicSmoothRel::y() const
 {
     return m_y;
 }
 
-void SVGPathSegCurvetoCubicSmoothRel::setX2(double x2)
+void SVGPathSegCurvetoCubicSmoothRel::setX2(float x2)
 {
     m_x2 = x2;
 }
 
-double SVGPathSegCurvetoCubicSmoothRel::x2() const
+float SVGPathSegCurvetoCubicSmoothRel::x2() const
 {
     return m_x2;
 }
 
-void SVGPathSegCurvetoCubicSmoothRel::setY2(double y2)
+void SVGPathSegCurvetoCubicSmoothRel::setY2(float y2)
 {
     m_y2 = y2;
 }
 
-double SVGPathSegCurvetoCubicSmoothRel::y2() const
+float SVGPathSegCurvetoCubicSmoothRel::y2() const
 {
     return m_y2;
 }
index 93429d3502c19e0023d37d8853e85c39b4b31278..430f194de9fc3fe3723dc3285570b19d6fd4c90f 100644 (file)
 
 #include "SVGPathSeg.h"
 
-namespace WebCore
-{
-    class SVGPathSegCurvetoCubicSmoothAbs : public SVGPathSeg
-    {
+namespace WebCore {
+
+    class SVGPathSegCurvetoCubicSmoothAbs : public SVGPathSeg {
     public:
-        SVGPathSegCurvetoCubicSmoothAbs(double x, double y, double x2, double y2);
+        SVGPathSegCurvetoCubicSmoothAbs(float x, float y, float x2, float y2);
         virtual ~SVGPathSegCurvetoCubicSmoothAbs();
 
         virtual unsigned short pathSegType() const { return PATHSEG_CURVETO_CUBIC_SMOOTH_ABS; }
         virtual String pathSegTypeAsLetter() const { return "S"; }
         virtual String toString() const { return String::format("S %.6lg %.6lg %.6lg %.6lg", m_x2, m_y2, m_x, m_y); }
 
-        void setX(double);
-        double x() const;
+        void setX(float);
+        float x() const;
 
-        void setY(double);
-        double y() const;
+        void setY(float);
+        float y() const;
 
-        void setX2(double);
-        double x2() const;
+        void setX2(float);
+        float x2() const;
 
-        void setY2(double);
-        double y2() const;
+        void setY2(float);
+        float y2() const;
 
     private:
-        double m_x;
-        double m_y;
-        double m_x2;
-        double m_y2;
+        float m_x;
+        float m_y;
+        float m_x2;
+        float m_y2;
     };
 
-    class SVGPathSegCurvetoCubicSmoothRel : public SVGPathSeg
-    { 
+    class SVGPathSegCurvetoCubicSmoothRel : public SVGPathSeg { 
     public:
-        SVGPathSegCurvetoCubicSmoothRel(double x, double y, double x2, double y2);
+        SVGPathSegCurvetoCubicSmoothRel(float x, float y, float x2, float y2);
         virtual ~SVGPathSegCurvetoCubicSmoothRel();
 
         virtual unsigned short pathSegType() const { return PATHSEG_CURVETO_CUBIC_SMOOTH_REL; }
         virtual String pathSegTypeAsLetter() const { return "s"; }
         virtual String toString() const { return String::format("s %.6lg %.6lg %.6lg %.6lg", m_x2, m_y2, m_x, m_y); }
 
-        void setX(double);
-        double x() const;
+        void setX(float);
+        float x() const;
 
-        void setY(double);
-        double y() const;
+        void setY(float);
+        float y() const;
 
-        void setX2(double);
-        double x2() const;
+        void setX2(float);
+        float x2() const;
 
-        void setY2(double);
-        double y2() const;
+        void setY2(float);
+        float y2() const;
 
     private:
-        double m_x;
-        double m_y;
-        double m_x2;
-        double m_y2;
+        float m_x;
+        float m_y;
+        float m_x2;
+        float m_y2;
     };
 
 } // namespace WebCore
index b19eca807a9d337be47fa6864f52f39818e0c38e..bda30fafc378a2b3009a42f3e09295279833ef1a 100644 (file)
@@ -29,7 +29,7 @@
 
 namespace WebCore {
 
-SVGPathSegCurvetoQuadraticAbs::SVGPathSegCurvetoQuadraticAbs(double x, double y, double x1, double y1)
+SVGPathSegCurvetoQuadraticAbs::SVGPathSegCurvetoQuadraticAbs(float x, float y, float x1, float y1)
     : SVGPathSeg()
     , m_x(x)
     , m_y(y)
@@ -42,42 +42,42 @@ SVGPathSegCurvetoQuadraticAbs::~SVGPathSegCurvetoQuadraticAbs()
 {
 }
 
-void SVGPathSegCurvetoQuadraticAbs::setX(double x)
+void SVGPathSegCurvetoQuadraticAbs::setX(float x)
 {
     m_x = x;
 }
 
-double SVGPathSegCurvetoQuadraticAbs::x() const
+float SVGPathSegCurvetoQuadraticAbs::x() const
 {
     return m_x;
 }
 
-void SVGPathSegCurvetoQuadraticAbs::setY(double y)
+void SVGPathSegCurvetoQuadraticAbs::setY(float y)
 {
     m_y = y;
 }
 
-double SVGPathSegCurvetoQuadraticAbs::y() const
+float SVGPathSegCurvetoQuadraticAbs::y() const
 {
     return m_y;
 }
 
-void SVGPathSegCurvetoQuadraticAbs::setX1(double x1)
+void SVGPathSegCurvetoQuadraticAbs::setX1(float x1)
 {
     m_x1 = x1;
 }
 
-double SVGPathSegCurvetoQuadraticAbs::x1() const
+float SVGPathSegCurvetoQuadraticAbs::x1() const
 {
     return m_x1;
 }
 
-void SVGPathSegCurvetoQuadraticAbs::setY1(double y1)
+void SVGPathSegCurvetoQuadraticAbs::setY1(float y1)
 {
     m_y1 = y1;
 }
 
-double SVGPathSegCurvetoQuadraticAbs::y1() const
+float SVGPathSegCurvetoQuadraticAbs::y1() const
 {
     return m_y1;
 }
@@ -85,7 +85,7 @@ double SVGPathSegCurvetoQuadraticAbs::y1() const
 
 
 
-SVGPathSegCurvetoQuadraticRel::SVGPathSegCurvetoQuadraticRel(double x, double y, double x1, double y1)
+SVGPathSegCurvetoQuadraticRel::SVGPathSegCurvetoQuadraticRel(float x, float y, float x1, float y1)
     : SVGPathSeg()
     , m_x(x)
     , m_y(y)
@@ -98,42 +98,42 @@ SVGPathSegCurvetoQuadraticRel::~SVGPathSegCurvetoQuadraticRel()
 {
 }
 
-void SVGPathSegCurvetoQuadraticRel::setX(double x)
+void SVGPathSegCurvetoQuadraticRel::setX(float x)
 {
     m_x = x;
 }
 
-double SVGPathSegCurvetoQuadraticRel::x() const
+float SVGPathSegCurvetoQuadraticRel::x() const
 {
     return m_x;
 }
 
-void SVGPathSegCurvetoQuadraticRel::setY(double y)
+void SVGPathSegCurvetoQuadraticRel::setY(float y)
 {
     m_y = y;
 }
 
-double SVGPathSegCurvetoQuadraticRel::y() const
+float SVGPathSegCurvetoQuadraticRel::y() const
 {
     return m_y;
 }
 
-void SVGPathSegCurvetoQuadraticRel::setX1(double x1)
+void SVGPathSegCurvetoQuadraticRel::setX1(float x1)
 {
     m_x1 = x1;
 }
 
-double SVGPathSegCurvetoQuadraticRel::x1() const
+float SVGPathSegCurvetoQuadraticRel::x1() const
 {
     return m_x1;
 }
 
-void SVGPathSegCurvetoQuadraticRel::setY1(double y1)
+void SVGPathSegCurvetoQuadraticRel::setY1(float y1)
 {
     m_y1 = y1;
 }
 
-double SVGPathSegCurvetoQuadraticRel::y1() const
+float SVGPathSegCurvetoQuadraticRel::y1() const
 {
     return m_y1;
 }
index 5142f311d3e23945f0356d9f323ee7d4163c3a09..5376de61b76f77b5476678b75af30af2e91c2e10 100644 (file)
 
 #include "SVGPathSeg.h"
 
-namespace WebCore
-{
-    class SVGPathSegCurvetoQuadraticAbs : public SVGPathSeg
-    { 
+namespace WebCore {
+
+    class SVGPathSegCurvetoQuadraticAbs : public SVGPathSeg { 
     public:
-        SVGPathSegCurvetoQuadraticAbs(double x, double y, double x1, double y1);
+        SVGPathSegCurvetoQuadraticAbs(float x, float y, float x1, float y1);
         virtual ~SVGPathSegCurvetoQuadraticAbs();
 
         virtual unsigned short pathSegType() const { return PATHSEG_CURVETO_QUADRATIC_ABS; }
         virtual String pathSegTypeAsLetter() const { return "Q"; }
         virtual String toString() const { return String::format("Q %.6lg %.6lg %.6lg %.6lg", m_x1, m_y1, m_x, m_y); }
 
-        void setX(double);
-        double x() const;
+        void setX(float);
+        float x() const;
 
-        void setY(double);
-        double y() const;
+        void setY(float);
+        float y() const;
 
-        void setX1(double);
-        double x1() const;
+        void setX1(float);
+        float x1() const;
 
-        void setY1(double);
-        double y1() const;
+        void setY1(float);
+        float y1() const;
 
     private:
-        double m_x;
-        double m_y;
-        double m_x1;
-        double m_y1;
+        float m_x;
+        float m_y;
+        float m_x1;
+        float m_y1;
     };
 
-    class SVGPathSegCurvetoQuadraticRel : public SVGPathSeg 
-    { 
+    class SVGPathSegCurvetoQuadraticRel : public SVGPathSeg {
     public:
-        SVGPathSegCurvetoQuadraticRel(double x, double y, double x1, double y1);
+        SVGPathSegCurvetoQuadraticRel(float x, float y, float x1, float y1);
         virtual ~SVGPathSegCurvetoQuadraticRel();
 
         virtual unsigned short pathSegType() const { return PATHSEG_CURVETO_QUADRATIC_REL; }
         virtual String pathSegTypeAsLetter() const { return "q"; }
         virtual String toString() const { return String::format("q %.6lg %.6lg %.6lg %.6lg", m_x1, m_y1, m_x, m_y); }
-        void setX(double);
-        double x() const;
 
-        void setY(double);
-        double y() const;
+        void setX(float);
+        float x() const;
+
+        void setY(float);
+        float y() const;
 
-        void setX1(double);
-        double x1() const;
+        void setX1(float);
+        float x1() const;
 
-        void setY1(double);
-        double y1() const;
+        void setY1(float);
+        float y1() const;
 
     private:
-        double m_x;
-        double m_y;
-        double m_x1;
-        double m_y1;
+        float m_x;
+        float m_y;
+        float m_x1;
+        float m_y1;
     };
 
 } // namespace WebCore
index 7eebb62e0a3d29e24d2717be43511f84e94edce9..12498e9a5e381614f610f7b438f6284ffe9f7219 100644 (file)
@@ -29,7 +29,7 @@
 
 namespace WebCore {
 
-SVGPathSegCurvetoQuadraticSmoothAbs::SVGPathSegCurvetoQuadraticSmoothAbs(double x, double y)
+SVGPathSegCurvetoQuadraticSmoothAbs::SVGPathSegCurvetoQuadraticSmoothAbs(float x, float y)
     : SVGPathSeg()
     , m_x(x)
     , m_y(y)
@@ -40,29 +40,29 @@ SVGPathSegCurvetoQuadraticSmoothAbs::~SVGPathSegCurvetoQuadraticSmoothAbs()
 {
 }
 
-void SVGPathSegCurvetoQuadraticSmoothAbs::setX(double x)
+void SVGPathSegCurvetoQuadraticSmoothAbs::setX(float x)
 {
     m_x = x;
 }
 
-double SVGPathSegCurvetoQuadraticSmoothAbs::x() const
+float SVGPathSegCurvetoQuadraticSmoothAbs::x() const
 {
     return m_x;
 }
 
-void SVGPathSegCurvetoQuadraticSmoothAbs::setY(double y)
+void SVGPathSegCurvetoQuadraticSmoothAbs::setY(float y)
 {
     m_y = y;
 }
 
-double SVGPathSegCurvetoQuadraticSmoothAbs::y() const
+float SVGPathSegCurvetoQuadraticSmoothAbs::y() const
 {
     return m_y;
 }
 
 
 
-SVGPathSegCurvetoQuadraticSmoothRel::SVGPathSegCurvetoQuadraticSmoothRel(double x, double y)
+SVGPathSegCurvetoQuadraticSmoothRel::SVGPathSegCurvetoQuadraticSmoothRel(float x, float y)
     : SVGPathSeg()
     , m_x(x)
     , m_y(y)
@@ -73,22 +73,22 @@ SVGPathSegCurvetoQuadraticSmoothRel::~SVGPathSegCurvetoQuadraticSmoothRel()
 {
 }
 
-void SVGPathSegCurvetoQuadraticSmoothRel::setX(double x)
+void SVGPathSegCurvetoQuadraticSmoothRel::setX(float x)
 {
     m_x = x;
 }
 
-double SVGPathSegCurvetoQuadraticSmoothRel::x() const
+float SVGPathSegCurvetoQuadraticSmoothRel::x() const
 {
     return m_x;
 }
 
-void SVGPathSegCurvetoQuadraticSmoothRel::setY(double y)
+void SVGPathSegCurvetoQuadraticSmoothRel::setY(float y)
 {
     m_y = y;
 }
 
-double SVGPathSegCurvetoQuadraticSmoothRel::y() const
+float SVGPathSegCurvetoQuadraticSmoothRel::y() const
 {
     return m_y;
 }
index 8b93bfd9bfcb3ef172455c932190edd18d35e5d9..2c34bda896e4374b1d9d5b54d6f7df9b22750c67 100644 (file)
 
 #include "SVGPathSeg.h"
 
-namespace WebCore
-{
-    class SVGPathSegCurvetoQuadraticSmoothAbs : public SVGPathSeg
-    { 
+namespace WebCore {
+
+    class SVGPathSegCurvetoQuadraticSmoothAbs : public SVGPathSeg {
     public:
-        SVGPathSegCurvetoQuadraticSmoothAbs(double x, double y);
+        SVGPathSegCurvetoQuadraticSmoothAbs(float x, float y);
         virtual ~SVGPathSegCurvetoQuadraticSmoothAbs();
 
         virtual unsigned short pathSegType() const { return PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS; }
         virtual String pathSegTypeAsLetter() const { return "T"; }
         virtual String toString() const { return String::format("T %.6lg %.6lg", m_x, m_y); }
 
-        void setX(double);
-        double x() const;
+        void setX(float);
+        float x() const;
 
-        void setY(double);
-        double y() const;
+        void setY(float);
+        float y() const;
 
     private:
-        double m_x;
-        double m_y;
+        float m_x;
+        float m_y;
     };
 
-    class SVGPathSegCurvetoQuadraticSmoothRel : public SVGPathSeg 
-    { 
+    class SVGPathSegCurvetoQuadraticSmoothRel : public SVGPathSeg {
     public:
-        SVGPathSegCurvetoQuadraticSmoothRel(double x, double y);
+        SVGPathSegCurvetoQuadraticSmoothRel(float x, float y);
         virtual ~SVGPathSegCurvetoQuadraticSmoothRel();
 
         virtual unsigned short pathSegType() const { return PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL; }
         virtual String pathSegTypeAsLetter() const { return "t"; }
         virtual String toString() const { return String::format("t %.6lg %.6lg", m_x, m_y); }
 
-        void setX(double);
-        double x() const;
+        void setX(float);
+        float x() const;
 
-        void setY(double);
-        double y() const;
+        void setY(float);
+        float y() const;
 
     private:
-        double m_x;
-        double m_y;
+        float m_x;
+        float m_y;
     };
 
 } // namespace WebCore
index 5e425b54151e7a9d739da49a439949a45f20e706..8b91c513a01cc17fb0a307bce6e1122ce2d958d9 100644 (file)
@@ -29,7 +29,7 @@
 
 namespace WebCore {
 
-SVGPathSegLinetoAbs::SVGPathSegLinetoAbs(double x, double y)
+SVGPathSegLinetoAbs::SVGPathSegLinetoAbs(float x, float y)
     : SVGPathSeg()
     , m_x(x)
     , m_y(y)
@@ -40,27 +40,27 @@ SVGPathSegLinetoAbs::~SVGPathSegLinetoAbs()
 {
 }
 
-void SVGPathSegLinetoAbs::setX(double x)
+void SVGPathSegLinetoAbs::setX(float x)
 {
     m_x = x;
 }
 
-double SVGPathSegLinetoAbs::x() const
+float SVGPathSegLinetoAbs::x() const
 {
     return m_x;
 }
 
-void SVGPathSegLinetoAbs::setY(double y)
+void SVGPathSegLinetoAbs::setY(float y)
 {
     m_y = y;
 }
 
-double SVGPathSegLinetoAbs::y() const
+float SVGPathSegLinetoAbs::y() const
 {
     return m_y;
 }
 
-SVGPathSegLinetoRel::SVGPathSegLinetoRel(double x, double y)
+SVGPathSegLinetoRel::SVGPathSegLinetoRel(float x, float y)
     : SVGPathSeg()
     , m_x(x)
     , m_y(y)
@@ -71,22 +71,22 @@ SVGPathSegLinetoRel::~SVGPathSegLinetoRel()
 {
 }
 
-void SVGPathSegLinetoRel::setX(double x)
+void SVGPathSegLinetoRel::setX(float x)
 {
     m_x = x;
 }
 
-double SVGPathSegLinetoRel::x() const
+float SVGPathSegLinetoRel::x() const
 {
     return m_x;
 }
 
-void SVGPathSegLinetoRel::setY(double y)
+void SVGPathSegLinetoRel::setY(float y)
 {
     m_y = y;
 }
 
-double SVGPathSegLinetoRel::y() const
+float SVGPathSegLinetoRel::y() const
 {
     return m_y;
 }
index d76c896cdb91f162dac6edfe8fc8eb003f82f40e..ef15757ae8e008c24897bb2386fd78bcffbe7d48 100644 (file)
 
 #include "SVGPathSeg.h"
 
-namespace WebCore
-{
-    class SVGPathSegLinetoAbs : public SVGPathSeg
-    { 
+namespace WebCore {
+    class SVGPathSegLinetoAbs : public SVGPathSeg { 
     public:
-        SVGPathSegLinetoAbs(double x, double y);
+        SVGPathSegLinetoAbs(float x, float y);
         virtual ~SVGPathSegLinetoAbs();
 
         virtual unsigned short pathSegType() const { return PATHSEG_LINETO_ABS; }
         virtual String pathSegTypeAsLetter() const { return "L"; }
         virtual String toString() const { return String::format("L %.6lg %.6lg", m_x, m_y); }
 
-        void setX(double);
-        double x() const;
+        void setX(float);
+        float x() const;
 
-        void setY(double);
-        double y() const;
+        void setY(float);
+        float y() const;
 
     private:
-        double m_x;
-        double m_y;
+        float m_x;
+        float m_y;
     };
 
-    class SVGPathSegLinetoRel : public SVGPathSeg
-    { 
+    class SVGPathSegLinetoRel : public SVGPathSeg { 
     public:
-        SVGPathSegLinetoRel(double x, double y);
+        SVGPathSegLinetoRel(float x, float y);
         virtual ~SVGPathSegLinetoRel();
 
         virtual unsigned short pathSegType() const { return PATHSEG_LINETO_REL; }
         virtual String pathSegTypeAsLetter() const { return "l"; }
         virtual String toString() const { return String::format("l %.6lg %.6lg", m_x, m_y); }
 
-        void setX(double);
-        double x() const;
+        void setX(float);
+        float x() const;
 
-        void setY(double);
-        double y() const;
+        void setY(float);
+        float y() const;
 
     private:
-        double m_x;
-        double m_y;
+        float m_x;
+        float m_y;
     };
 
 } // namespace WebCore
index bb1a01316d8680746a0fc9173fe3f3f8eb9e4887..3c8f72039441879b6763af4e973f99e33ee371fd 100644 (file)
@@ -29,7 +29,7 @@
 
 namespace WebCore {
 
-SVGPathSegLinetoHorizontalAbs::SVGPathSegLinetoHorizontalAbs(double x)
+SVGPathSegLinetoHorizontalAbs::SVGPathSegLinetoHorizontalAbs(float x)
     : SVGPathSeg()
     , m_x(x)
 {
@@ -39,19 +39,19 @@ SVGPathSegLinetoHorizontalAbs::~SVGPathSegLinetoHorizontalAbs()
 {
 }
 
-void SVGPathSegLinetoHorizontalAbs::setX(double x)
+void SVGPathSegLinetoHorizontalAbs::setX(float x)
 {
     m_x = x;
 }
 
-double SVGPathSegLinetoHorizontalAbs::x() const
+float SVGPathSegLinetoHorizontalAbs::x() const
 {
     return m_x;
 }
 
 
 
-SVGPathSegLinetoHorizontalRel::SVGPathSegLinetoHorizontalRel(double x)
+SVGPathSegLinetoHorizontalRel::SVGPathSegLinetoHorizontalRel(float x)
     : SVGPathSeg()
     , m_x(x)
 {
@@ -61,12 +61,12 @@ SVGPathSegLinetoHorizontalRel::~SVGPathSegLinetoHorizontalRel()
 {
 }
 
-void SVGPathSegLinetoHorizontalRel::setX(double x)
+void SVGPathSegLinetoHorizontalRel::setX(float x)
 {
     m_x = x;
 }
 
-double SVGPathSegLinetoHorizontalRel::x() const
+float SVGPathSegLinetoHorizontalRel::x() const
 {
     return m_x;
 }
index db335f00609070fada4163a07a08bf396c278d7c..fd4ac3df7321ea9c46f856b92253d4ba8d60a95a 100644 (file)
 
 #include "SVGPathSeg.h"
 
-namespace WebCore
-{
-    class SVGPathSegLinetoHorizontalAbs : public SVGPathSeg
-    {
+namespace WebCore {
+
+    class SVGPathSegLinetoHorizontalAbs : public SVGPathSeg {
     public:
-        SVGPathSegLinetoHorizontalAbs(double x);
+        SVGPathSegLinetoHorizontalAbs(float x);
         virtual ~SVGPathSegLinetoHorizontalAbs();
 
         virtual unsigned short pathSegType() const { return PATHSEG_LINETO_HORIZONTAL_ABS; }
         virtual String pathSegTypeAsLetter() const { return "H"; }
         virtual String toString() const { return String::format("H %.6lg", m_x); }
 
-        void setX(double);
-        double x() const;
+        void setX(float);
+        float x() const;
 
     private:
-        double m_x;
+        float m_x;
     };
 
-    class SVGPathSegLinetoHorizontalRel : public SVGPathSeg
-    {
+    class SVGPathSegLinetoHorizontalRel : public SVGPathSeg {
     public:
-        SVGPathSegLinetoHorizontalRel(double x);
+        SVGPathSegLinetoHorizontalRel(float x);
         virtual ~SVGPathSegLinetoHorizontalRel();
 
         virtual unsigned short pathSegType() const { return PATHSEG_LINETO_HORIZONTAL_REL; }
         virtual String pathSegTypeAsLetter() const { return "h"; }
         virtual String toString() const { return String::format("h %.6lg", m_x); }
 
-        void setX(double);
-        double x() const;
+        void setX(float);
+        float x() const;
 
     private:
-        double m_x;
+        float m_x;
     };
 
 } // namespace WebCore
index 31e6ded02a916bd35b2cc95b7cd3eddfab8da941..dfbe0e10d4499df14fe990cb8be3ab730cdfb6ee 100644 (file)
@@ -29,7 +29,7 @@
 
 namespace WebCore {
 
-SVGPathSegLinetoVerticalAbs::SVGPathSegLinetoVerticalAbs(double y)
+SVGPathSegLinetoVerticalAbs::SVGPathSegLinetoVerticalAbs(float y)
     : SVGPathSeg()
     , m_y(y)
 {
@@ -39,12 +39,12 @@ SVGPathSegLinetoVerticalAbs::~SVGPathSegLinetoVerticalAbs()
 {
 }
 
-void SVGPathSegLinetoVerticalAbs::setY(double y)
+void SVGPathSegLinetoVerticalAbs::setY(float y)
 {
     m_y = y;
 }
 
-double SVGPathSegLinetoVerticalAbs::y() const
+float SVGPathSegLinetoVerticalAbs::y() const
 {
     return m_y;
 }
@@ -52,7 +52,7 @@ double SVGPathSegLinetoVerticalAbs::y() const
 
 
 
-SVGPathSegLinetoVerticalRel::SVGPathSegLinetoVerticalRel(double y)
+SVGPathSegLinetoVerticalRel::SVGPathSegLinetoVerticalRel(float y)
     : SVGPathSeg()
     , m_y(y)
 {
@@ -62,12 +62,12 @@ SVGPathSegLinetoVerticalRel::~SVGPathSegLinetoVerticalRel()
 {
 }
 
-void SVGPathSegLinetoVerticalRel::setY(double y)
+void SVGPathSegLinetoVerticalRel::setY(float y)
 {
     m_y = y;
 }
 
-double SVGPathSegLinetoVerticalRel::y() const
+float SVGPathSegLinetoVerticalRel::y() const
 {
     return m_y;
 }
index 7d3e414d446ddb010054364cc51f9e221b318335..22f18edb034940dd2f77d42319f2abc7420f00e5 100644 (file)
 
 #include "SVGPathSeg.h"
 
-namespace WebCore
-{
-    class SVGPathSegLinetoVerticalAbs : public SVGPathSeg
-    {
+namespace WebCore {
+
+    class SVGPathSegLinetoVerticalAbs : public SVGPathSeg {
     public:
-        SVGPathSegLinetoVerticalAbs(double y);
+        SVGPathSegLinetoVerticalAbs(float y);
         virtual~SVGPathSegLinetoVerticalAbs();
 
         virtual unsigned short pathSegType() const { return PATHSEG_LINETO_VERTICAL_ABS; }
         virtual String pathSegTypeAsLetter() const { return "V"; }
         virtual String toString() const { return String::format("V %.6lg", m_y); }
 
-        void setY(double);
-        double y() const;
+        void setY(float);
+        float y() const;
 
     private:
-        double m_y;
+        float m_y;
     };
 
-    class SVGPathSegLinetoVerticalRel : public SVGPathSeg
-    {
+    class SVGPathSegLinetoVerticalRel : public SVGPathSeg {
     public:
-        SVGPathSegLinetoVerticalRel(double y);
+        SVGPathSegLinetoVerticalRel(float y);
         virtual ~SVGPathSegLinetoVerticalRel();
 
         virtual unsigned short pathSegType() const { return PATHSEG_LINETO_VERTICAL_REL; }
         virtual String pathSegTypeAsLetter() const { return "v"; }
         virtual String toString() const { return String::format("v %.6lg", m_y); }
 
-        void setY(double);
-        double y() const;
+        void setY(float);
+        float y() const;
 
     private:
-        double m_y;
+        float m_y;
     };
 
 } // namespace WebCore
index 21d58409db836b331c684e5816d25992b06ef7cd..7315ea25848b308bcf5c6f6c0a7a2c6c7984fb77 100644 (file)
@@ -50,7 +50,7 @@ const SVGElement* SVGPathSegList::context() const
     return m_context;
 }
 
-unsigned SVGPathSegList::getPathSegAtLength(double)
+unsigned SVGPathSegList::getPathSegAtLength(float)
 {
     // FIXME : to be useful this will need to support non-normalized SVGPathSegLists
     ExceptionCode ec = 0;
index 4176dcb745d8e2eba7736d8259a17ffaca47dd82..4d1e54aaa02542bbbda177656cef324004d092ec 100644 (file)
 #include "SVGList.h"
 #include "SVGPathSeg.h"
 
-namespace WebCore
-{
+namespace WebCore {
+
     class Path;
     class SVGElement;
  
-    class SVGPathSegList : public SVGList<RefPtr<SVGPathSeg> >
-    {
+    class SVGPathSegList : public SVGList<RefPtr<SVGPathSeg> > {
     public:
         SVGPathSegList(const SVGElement* context);
         virtual ~SVGPathSegList();
 
         const SVGElement* context() const;
-        
-        unsigned getPathSegAtLength(double);
+
+        unsigned getPathSegAtLength(float);
         Path toPathData();
 
     private:
index 3ac9bfa184e9853f7a5d64b697fa4c84d7d3e31a..dbe7f74a8308cddd1dd97ca885f33341f58054e6 100644 (file)
@@ -29,7 +29,7 @@
 
 namespace WebCore {
 
-SVGPathSegMovetoAbs::SVGPathSegMovetoAbs(double x, double y)
+SVGPathSegMovetoAbs::SVGPathSegMovetoAbs(float x, float y)
     : SVGPathSeg()
     , m_x(x)
     , m_y(y)
@@ -40,22 +40,22 @@ SVGPathSegMovetoAbs::~SVGPathSegMovetoAbs()
 {
 }
 
-void SVGPathSegMovetoAbs::setX(double x)
+void SVGPathSegMovetoAbs::setX(float x)
 {
     m_x = x;
 }
 
-double SVGPathSegMovetoAbs::x() const
+float SVGPathSegMovetoAbs::x() const
 {
     return m_x;
 }
 
-void SVGPathSegMovetoAbs::setY(double y)
+void SVGPathSegMovetoAbs::setY(float y)
 {
     m_y = y;
 }
 
-double SVGPathSegMovetoAbs::y() const
+float SVGPathSegMovetoAbs::y() const
 {
     return m_y;
 }
@@ -63,7 +63,7 @@ double SVGPathSegMovetoAbs::y() const
 
 
 
-SVGPathSegMovetoRel::SVGPathSegMovetoRel(double x, double y)
+SVGPathSegMovetoRel::SVGPathSegMovetoRel(float x, float y)
     : SVGPathSeg()
     , m_x(x)
     , m_y(y)
@@ -74,22 +74,22 @@ SVGPathSegMovetoRel::~SVGPathSegMovetoRel()
 {
 }
 
-void SVGPathSegMovetoRel::setX(double x)
+void SVGPathSegMovetoRel::setX(float x)
 {
     m_x = x;
 }
 
-double SVGPathSegMovetoRel::x() const
+float SVGPathSegMovetoRel::x() const
 {
     return m_x;
 }
 
-void SVGPathSegMovetoRel::setY(double y)
+void SVGPathSegMovetoRel::setY(float y)
 {
     m_y = y;
 }
 
-double SVGPathSegMovetoRel::y() const
+float SVGPathSegMovetoRel::y() const
 {
     return m_y;
 }
index fbd62331e8881a9720af773d60cc9c7b078547c2..34c4bf9dc79375b26934256a6fba219077cb4257 100644 (file)
 
 #include "SVGPathSeg.h"
 
-namespace WebCore
-{
-    class SVGPathSegMovetoAbs : public SVGPathSeg
-    { 
+namespace WebCore {
+    class SVGPathSegMovetoAbs : public SVGPathSeg { 
     public:
-        SVGPathSegMovetoAbs(double x, double y);
+        SVGPathSegMovetoAbs(float x, float y);
         virtual ~SVGPathSegMovetoAbs();
 
         virtual unsigned short pathSegType() const { return PATHSEG_MOVETO_ABS; }
         virtual String pathSegTypeAsLetter() const { return "M"; }
         virtual String toString() const { return String::format("M %.6lg %.6lg", m_x, m_y); }
 
-        void setX(double);
-        double x() const;
+        void setX(float);
+        float x() const;
 
-        void setY(double);
-        double y() const;
+        void setY(float);
+        float y() const;
 
     private:
-        double m_x;
-        double m_y;
+        float m_x;
+        float m_y;
     };
 
-    class SVGPathSegMovetoRel : public SVGPathSeg
-    { 
+    class SVGPathSegMovetoRel : public SVGPathSeg { 
     public:
-        SVGPathSegMovetoRel(double x, double y);
+        SVGPathSegMovetoRel(float x, float y);
         virtual ~SVGPathSegMovetoRel();
 
         virtual unsigned short pathSegType() const { return PATHSEG_MOVETO_REL; }
         virtual String pathSegTypeAsLetter() const { return "m"; }
         virtual String toString() const { return String::format("m %.6lg %.6lg", m_x, m_y); }
 
-        void setX(double);
-        double x() const;
+        void setX(float);
+        float x() const;
 
-        void setY(double);
-        double y() const;
+        void setY(float);
+        float y() const;
 
     private:
-        double m_x;
-        double m_y;
+        float m_x;
+        float m_y;
     };
 
 } // namespace WebCore
index a2f5fa305eb3353f720c7bad430e429def6f387f..712e2ff5de274d8b04e3ffab8e96841077d7dfc8 100644 (file)
@@ -26,6 +26,7 @@
 #include "SVGPolyElement.h"
 
 #include "Document.h"
+#include "FloatPoint.h"
 #include "SVGNames.h"
 #include "SVGPointList.h"
 
@@ -84,7 +85,7 @@ void SVGPolyElement::parseMappedAttribute(MappedAttribute* attr)
 void SVGPolyElement::svgPolyTo(double x1, double y1, int) const
 {
     ExceptionCode ec = 0;
-    points()->appendItem(FloatPoint(x1, y1), ec);
+    points()->appendItem(FloatPoint::narrowPrecision(x1, y1), ec);
 }
 
 void SVGPolyElement::notifyAttributeChange() const
index 9ed9afb47ec7cfae3a9bf09abf384a47ae8efa99..0a502cc1c966eedaa8a544a30982420f1e0c5e38 100644 (file)
@@ -26,6 +26,7 @@
 #include "SVGRadialGradientElement.h"
 
 #include "FloatConversion.h"
+#include "FloatPoint.h"
 #include "RadialGradientAttributes.h"
 #include "SVGLength.h"
 #include "SVGNames.h"
@@ -94,8 +95,8 @@ void SVGRadialGradientElement::buildGradient() const
     radialGradient->setBoundingBoxMode(attributes.boundingBoxMode());
     radialGradient->setGradientSpreadMethod(attributes.spreadMethod()); 
     radialGradient->setGradientTransform(attributes.gradientTransform());
-    radialGradient->setGradientCenter(FloatPoint(attributes.cx(), attributes.cy()));
-    radialGradient->setGradientFocal(FloatPoint(attributes.fx(), attributes.fy()));
+    radialGradient->setGradientCenter(FloatPoint::narrowPrecision(attributes.cx(), attributes.cy()));
+    radialGradient->setGradientFocal(FloatPoint::narrowPrecision(attributes.fx(), attributes.fy()));
     radialGradient->setGradientRadius(narrowPrecisionToFloat(attributes.r()));
 }
 
index f72a218f082bfdb3e34fdec1f8312c225738c5e4..88471ae5ab660057a43f6ed55da3e31f5767233e 100644 (file)
@@ -31,6 +31,8 @@
 #include "Document.h"
 #include "EventListener.h"
 #include "EventNames.h"
+#include "FloatConversion.h"
+#include "FloatRect.h"
 #include "Frame.h"
 #include "HTMLNames.h"
 #include "RenderSVGContainer.h"
@@ -116,12 +118,14 @@ FloatRect SVGSVGElement::viewport() const
         _x = x().value();
         _y = y().value();
     }
-    double w = width().value();
-    double h = height().value();
+    float w = width().value();
+    float h = height().value();
     AffineTransform viewBox = viewBoxToViewTransform(w, h);
+    double wDouble = w;
+    double hDouble = h;
     viewBox.map(_x, _y, &_x, &_y);
-    viewBox.map(w, h, &w, &h);
-    return FloatRect(_x, _y, w, h);
+    viewBox.map(w, h, &wDouble, &hDouble);
+    return FloatRect::narrowPrecision(_x, _y, wDouble, hDouble);
 }
 
 float SVGSVGElement::pixelUnitToMillimeterX() const
@@ -423,7 +427,7 @@ bool SVGSVGElement::animationsPaused() const
 
 float SVGSVGElement::getCurrentTime() const
 {
-    return m_timeScheduler->elapsed();
+    return narrowPrecisionToFloat(m_timeScheduler->elapsed());
 }
 
 void SVGSVGElement::setCurrentTime(float /* seconds */)
index 38c8c72e48aa0346bc2bbd603d76fd7b57b4ebcb..74a92e411991ce4eab8d7dcf38f2c74f613dca37 100644 (file)
@@ -33,7 +33,7 @@ namespace WebCore {
 
 SVGStopElement::SVGStopElement(const QualifiedName& tagName, Document* doc)
     : SVGStyledElement(tagName, doc)
-    , m_offset(0.0)
+    , m_offset(0.0f)
 {
 }
 
@@ -41,16 +41,16 @@ SVGStopElement::~SVGStopElement()
 {
 }
 
-ANIMATED_PROPERTY_DEFINITIONS(SVGStopElement, double, Number, number, Offset, offset, SVGNames::offsetAttr.localName(), m_offset)
+ANIMATED_PROPERTY_DEFINITIONS(SVGStopElement, float, Number, number, Offset, offset, SVGNames::offsetAttr.localName(), m_offset)
 
 void SVGStopElement::parseMappedAttribute(MappedAttribute* attr)
 {
     if (attr->name() == SVGNames::offsetAttr) {
         const String& value = attr->value();
         if (value.endsWith("%"))
-            setOffsetBaseValue(value.left(value.length() - 1).toDouble() / 100.);
+            setOffsetBaseValue(value.left(value.length() - 1).toFloat() / 100.0f);
         else
-            setOffsetBaseValue(value.toDouble());
+            setOffsetBaseValue(value.toFloat());
     } else
         SVGStyledElement::parseMappedAttribute(attr);
 }
index 8450b0d24eb569f9a7f87863d18454ce455bd534..55d128b55c8e15457f8ea7e6371c3fd50eac2a94 100644 (file)
@@ -43,7 +43,7 @@ namespace WebCore
         virtual RenderObject* createRenderer(RenderArena*, RenderStyle*);
         
     private:
-        ANIMATED_PROPERTY_DECLARATIONS(SVGStopElement, double, double, Offset, offset)
+        ANIMATED_PROPERTY_DECLARATIONS(SVGStopElement, float, float, Offset, offset)
     };
 
 } // namespace WebCore
index 0cdaae99276d2b9e2e7ad33113c15a1f5a1ce6da..48696387d894b6714984ef0ff092265e08bcb59f 100644 (file)
 #include "config.h"
 #if ENABLE(SVG)
 
+#include "FloatPoint.h"
+#include "FloatSize.h"
 #include "SVGAngle.h"
-#include "SVGTransform.h"
 #include "SVGSVGElement.h"
+#include "SVGTransform.h"
 
 #include <math.h>
 
@@ -100,7 +102,7 @@ void SVGTransform::setTranslate(float tx, float ty)
 
 FloatPoint SVGTransform::translate() const
 {
-    return FloatPoint(m_matrix.e(), m_matrix.f());
+    return FloatPoint::narrowPrecision(m_matrix.e(), m_matrix.f());
 }
 
 void SVGTransform::setScale(float sx, float sy)
@@ -115,7 +117,7 @@ void SVGTransform::setScale(float sx, float sy)
 
 FloatSize SVGTransform::scale() const
 {
-    return FloatSize(m_matrix.a(), m_matrix.d());
+    return FloatSize::narrowPrecision(m_matrix.a(), m_matrix.d());
 }
 
 void SVGTransform::setRotate(float angle, float cx, float cy)
index d149e53c55f7b6497b30fc3c85b676299607a679..6330e46d18c055eb864182116e956827a3daff54 100644 (file)
@@ -23,6 +23,7 @@
 #if ENABLE(SVG)
 #include "SVGTransformDistance.h"
 
+#include "FloatConversion.h"
 #include "FloatPoint.h"
 #include "FloatSize.h"
 #include "SVGTransform.h"
@@ -214,14 +215,14 @@ SVGTransform SVGTransformDistance::addToSVGTransform(const SVGTransform& transfo
     case SVGTransform::SVG_TRANSFORM_TRANSLATE:
     {
         FloatPoint translation = transform.translate();
-        translation += FloatSize(m_transform.e(), m_transform.f());
+        translation += FloatSize::narrowPrecision(m_transform.e(), m_transform.f());
         newTransform.setTranslate(translation.x(), translation.y());
         return newTransform;
     }
     case SVGTransform::SVG_TRANSFORM_SCALE:
     {
         FloatSize scale = transform.scale();
-        scale += FloatSize(m_transform.a(), m_transform.d());
+        scale += FloatSize::narrowPrecision(m_transform.a(), m_transform.d());
         newTransform.setScale(scale.width(), scale.height());
         return newTransform;
     }
@@ -229,14 +230,16 @@ SVGTransform SVGTransformDistance::addToSVGTransform(const SVGTransform& transfo
     {
         // FIXME: I'm not certain the translation is calculated correctly here
         FloatPoint center = transform.rotationCenter();
-        newTransform.setRotate(transform.angle() + m_angle, center.x() + m_cx, center.y() + m_cy);
+        newTransform.setRotate(narrowPrecisionToFloat(transform.angle() + m_angle),
+                               narrowPrecisionToFloat(center.x() + m_cx),
+                               narrowPrecisionToFloat(center.y() + m_cy));
         return newTransform;
     }
     case SVGTransform::SVG_TRANSFORM_SKEWX:
-        newTransform.setSkewX(transform.angle() + m_angle);
+        newTransform.setSkewX(narrowPrecisionToFloat(transform.angle() + m_angle));
         return newTransform;
     case SVGTransform::SVG_TRANSFORM_SKEWY:
-        newTransform.setSkewY(transform.angle() + m_angle);
+        newTransform.setSkewY(narrowPrecisionToFloat(transform.angle() + m_angle));
         return newTransform;
     }
     
@@ -255,16 +258,16 @@ float SVGTransformDistance::distance() const
     case SVGTransform::SVG_TRANSFORM_UNKNOWN:
         return 0.0f;
     case SVGTransform::SVG_TRANSFORM_ROTATE:
-        return sqrtf(m_angle * m_angle + m_cx * m_cx + m_cy * m_cy);
+        return narrowPrecisionToFloat(sqrt(m_angle * m_angle + m_cx * m_cx + m_cy * m_cy));
     case SVGTransform::SVG_TRANSFORM_MATRIX:
         return 0.0f; // I'm not quite sure yet what distance between two matrices means.
     case SVGTransform::SVG_TRANSFORM_SCALE:
-        return sqrtf(m_transform.a() * m_transform.a() + m_transform.d() * m_transform.d());
+        return narrowPrecisionToFloat(sqrt(m_transform.a() * m_transform.a() + m_transform.d() * m_transform.d()));
     case SVGTransform::SVG_TRANSFORM_TRANSLATE:
-        return sqrtf(m_transform.e() * m_transform.e() + m_transform.f() * m_transform.f());
+        return narrowPrecisionToFloat(sqrt(m_transform.e() * m_transform.e() + m_transform.f() * m_transform.f()));
     case SVGTransform::SVG_TRANSFORM_SKEWX:
     case SVGTransform::SVG_TRANSFORM_SKEWY:
-        return m_angle;
+        return narrowPrecisionToFloat(m_angle);
     }
     ASSERT_NOT_REACHED();
     return 0.0f;
index 9daefb32ea9c930b555f2e6532f6b690441195a5..337eb223c1d49b5b0388d8d6edd432f28db23547 100644 (file)
@@ -24,8 +24,9 @@
 #if ENABLE(SVG)
 #include "SVGTransformable.h"
 
-#include "RegularExpression.h"
 #include "AffineTransform.h"
+#include "FloatConversion.h"
+#include "RegularExpression.h"
 #include "SVGNames.h"
 #include "SVGParserUtilities.h"
 #include "SVGStyledElement.h"
@@ -166,28 +167,28 @@ bool SVGTransformable::parseTransformAttribute(SVGTransformList* list, const Ato
 
         switch (type) {
             case SVGTransform::SVG_TRANSFORM_SKEWX:
-               t.setSkewX(x[0]);
+               t.setSkewX(narrowPrecisionToFloat(x[0]));
                 break;
             case SVGTransform::SVG_TRANSFORM_SKEWY:
-               t.setSkewY(x[0]);
+               t.setSkewY(narrowPrecisionToFloat(x[0]));
                 break;
             case SVGTransform::SVG_TRANSFORM_SCALE:
                   if (nr == 1) // Spec: if only one param given, assume uniform scaling
-                      t.setScale(x[0], x[0]);
+                      t.setScale(narrowPrecisionToFloat(x[0]), narrowPrecisionToFloat(x[0]));
                   else
-                      t.setScale(x[0], x[1]);
+                      t.setScale(narrowPrecisionToFloat(x[0]), narrowPrecisionToFloat(x[1]));
                 break;
             case SVGTransform::SVG_TRANSFORM_TRANSLATE:
                   if (nr == 1) // Spec: if only one param given, assume 2nd param to be 0
-                      t.setTranslate(x[0], 0);
+                      t.setTranslate(narrowPrecisionToFloat(x[0]), 0);
                   else
-                      t.setTranslate(x[0], x[1]);
+                      t.setTranslate(narrowPrecisionToFloat(x[0]), narrowPrecisionToFloat(x[1]));
                 break;
             case SVGTransform::SVG_TRANSFORM_ROTATE:
                   if (nr == 1)
-                      t.setRotate(x[0], 0, 0);
+                      t.setRotate(narrowPrecisionToFloat(x[0]), 0, 0);
                   else
-                      t.setRotate(x[0], x[1], x[2]);
+                      t.setRotate(narrowPrecisionToFloat(x[0]), narrowPrecisionToFloat(x[1]), narrowPrecisionToFloat(x[2]));
                 break;
             case SVGTransform::SVG_TRANSFORM_MATRIX:
                 t.setMatrix(AffineTransform(x[0], x[1], x[2], x[3], x[4], x[5]));