--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/WebCore/svg/SVGTransformable.cpp Fri Sep 17 09:02:29 2010 +0300
@@ -0,0 +1,225 @@
+/*
+ Copyright (C) 2004, 2005, 2008 Nikolas Zimmermann <zimmermann@kde.org>
+ 2004, 2005, 2006, 2007 Rob Buis <buis@kde.org>
+ 2007 Eric Seidel <eric@webkit.org>
+
+ This file is part of the WebKit project
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Library General Public
+ License as published by the Free Software Foundation; either
+ version 2 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Library General Public License for more details.
+
+ You should have received a copy of the GNU Library General Public License
+ along with this library; see the file COPYING.LIB. If not, write to
+ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+ Boston, MA 02110-1301, USA.
+*/
+
+#include "config.h"
+
+#if ENABLE(SVG)
+#include "SVGTransformable.h"
+
+#include "AffineTransform.h"
+#include "FloatConversion.h"
+#include "SVGNames.h"
+#include "SVGParserUtilities.h"
+#include "SVGStyledElement.h"
+#include "SVGTransformList.h"
+
+namespace WebCore {
+
+SVGTransformable::SVGTransformable()
+ : SVGLocatable()
+{
+}
+
+SVGTransformable::~SVGTransformable()
+{
+}
+
+static int parseTransformParamList(const UChar*& ptr, const UChar* end, float* values, int required, int optional)
+{
+ int optionalParams = 0, requiredParams = 0;
+
+ if (!skipOptionalSpaces(ptr, end) || *ptr != '(')
+ return -1;
+
+ ptr++;
+
+ skipOptionalSpaces(ptr, end);
+
+ while (requiredParams < required) {
+ if (ptr >= end || !parseNumber(ptr, end, values[requiredParams], false))
+ return -1;
+ requiredParams++;
+ if (requiredParams < required)
+ skipOptionalSpacesOrDelimiter(ptr, end);
+ }
+ if (!skipOptionalSpaces(ptr, end))
+ return -1;
+
+ bool delimParsed = skipOptionalSpacesOrDelimiter(ptr, end);
+
+ if (ptr >= end)
+ return -1;
+
+ if (*ptr == ')') { // skip optionals
+ ptr++;
+ if (delimParsed)
+ return -1;
+ } else {
+ while (optionalParams < optional) {
+ if (ptr >= end || !parseNumber(ptr, end, values[requiredParams + optionalParams], false))
+ return -1;
+ optionalParams++;
+ if (optionalParams < optional)
+ skipOptionalSpacesOrDelimiter(ptr, end);
+ }
+
+ if (!skipOptionalSpaces(ptr, end))
+ return -1;
+
+ delimParsed = skipOptionalSpacesOrDelimiter(ptr, end);
+
+ if (ptr >= end || *ptr != ')' || delimParsed)
+ return -1;
+ ptr++;
+ }
+
+ return requiredParams + optionalParams;
+}
+
+// These should be kept in sync with enum SVGTransformType
+static const int requiredValuesForType[] = {0, 6, 1, 1, 1, 1, 1};
+static const int optionalValuesForType[] = {0, 0, 1, 1, 2, 0, 0};
+
+bool SVGTransformable::parseTransformValue(unsigned type, const UChar*& ptr, const UChar* end, SVGTransform& t)
+{
+ if (type == SVGTransform::SVG_TRANSFORM_UNKNOWN)
+ return false;
+
+ int valueCount = 0;
+ float values[] = {0, 0, 0, 0, 0, 0};
+ if ((valueCount = parseTransformParamList(ptr, end, values, requiredValuesForType[type], optionalValuesForType[type])) < 0)
+ return false;
+
+ switch (type) {
+ case SVGTransform::SVG_TRANSFORM_SKEWX:
+ t.setSkewX(values[0]);
+ break;
+ case SVGTransform::SVG_TRANSFORM_SKEWY:
+ t.setSkewY(values[0]);
+ break;
+ case SVGTransform::SVG_TRANSFORM_SCALE:
+ if (valueCount == 1) // Spec: if only one param given, assume uniform scaling
+ t.setScale(values[0], values[0]);
+ else
+ t.setScale(values[0], values[1]);
+ break;
+ case SVGTransform::SVG_TRANSFORM_TRANSLATE:
+ if (valueCount == 1) // Spec: if only one param given, assume 2nd param to be 0
+ t.setTranslate(values[0], 0);
+ else
+ t.setTranslate(values[0], values[1]);
+ break;
+ case SVGTransform::SVG_TRANSFORM_ROTATE:
+ if (valueCount == 1)
+ t.setRotate(values[0], 0, 0);
+ else
+ t.setRotate(values[0], values[1], values[2]);
+ break;
+ case SVGTransform::SVG_TRANSFORM_MATRIX:
+ t.setMatrix(AffineTransform(values[0], values[1], values[2], values[3], values[4], values[5]));
+ break;
+ }
+
+ return true;
+}
+
+static const UChar skewXDesc[] = {'s', 'k', 'e', 'w', 'X'};
+static const UChar skewYDesc[] = {'s', 'k', 'e', 'w', 'Y'};
+static const UChar scaleDesc[] = {'s', 'c', 'a', 'l', 'e'};
+static const UChar translateDesc[] = {'t', 'r', 'a', 'n', 's', 'l', 'a', 't', 'e'};
+static const UChar rotateDesc[] = {'r', 'o', 't', 'a', 't', 'e'};
+static const UChar matrixDesc[] = {'m', 'a', 't', 'r', 'i', 'x'};
+
+static inline bool parseAndSkipType(const UChar*& currTransform, const UChar* end, unsigned short& type)
+{
+ if (currTransform >= end)
+ return false;
+
+ if (*currTransform == 's') {
+ if (skipString(currTransform, end, skewXDesc, sizeof(skewXDesc) / sizeof(UChar)))
+ type = SVGTransform::SVG_TRANSFORM_SKEWX;
+ else if (skipString(currTransform, end, skewYDesc, sizeof(skewYDesc) / sizeof(UChar)))
+ type = SVGTransform::SVG_TRANSFORM_SKEWY;
+ else if (skipString(currTransform, end, scaleDesc, sizeof(scaleDesc) / sizeof(UChar)))
+ type = SVGTransform::SVG_TRANSFORM_SCALE;
+ else
+ return false;
+ } else if (skipString(currTransform, end, translateDesc, sizeof(translateDesc) / sizeof(UChar)))
+ type = SVGTransform::SVG_TRANSFORM_TRANSLATE;
+ else if (skipString(currTransform, end, rotateDesc, sizeof(rotateDesc) / sizeof(UChar)))
+ type = SVGTransform::SVG_TRANSFORM_ROTATE;
+ else if (skipString(currTransform, end, matrixDesc, sizeof(matrixDesc) / sizeof(UChar)))
+ type = SVGTransform::SVG_TRANSFORM_MATRIX;
+ else
+ return false;
+
+ return true;
+}
+
+bool SVGTransformable::parseTransformAttribute(SVGTransformList* list, const AtomicString& transform)
+{
+ const UChar* start = transform.characters();
+ return parseTransformAttribute(list, start, start + transform.length());
+}
+
+bool SVGTransformable::parseTransformAttribute(SVGTransformList* list, const UChar*& currTransform, const UChar* end, TransformParsingMode mode)
+{
+ ExceptionCode ec = 0;
+ if (mode == ClearList) {
+ list->clear(ec);
+ ASSERT(!ec);
+ }
+
+ bool delimParsed = false;
+ while (currTransform < end) {
+ delimParsed = false;
+ unsigned short type = SVGTransform::SVG_TRANSFORM_UNKNOWN;
+ skipOptionalSpaces(currTransform, end);
+
+ if (!parseAndSkipType(currTransform, end, type))
+ return false;
+
+ SVGTransform t;
+ if (!parseTransformValue(type, currTransform, end, t))
+ return false;
+
+ list->appendItem(t, ec);
+ skipOptionalSpaces(currTransform, end);
+ if (currTransform < end && *currTransform == ',') {
+ delimParsed = true;
+ ++currTransform;
+ }
+ skipOptionalSpaces(currTransform, end);
+ }
+
+ return !delimParsed;
+}
+
+bool SVGTransformable::isKnownAttribute(const QualifiedName& attrName)
+{
+ return attrName == SVGNames::transformAttr;
+}
+
+}
+
+#endif // ENABLE(SVG)