third_party/blink/renderer/core/svg/svg_transform.cc

/*
 * Copyright (C) 2004, 2005 Nikolas Zimmermann <zimmermann@kde.org>
 * Copyright (C) 2004, 2005 Rob Buis <buis@kde.org>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * 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 "third_party/blink/renderer/core/svg/svg_transform.h"

#include "base/stl_util.h"
#include "third_party/blink/renderer/platform/geometry/float_size.h"
#include "third_party/blink/renderer/platform/wtf/math_extras.h"
#include "third_party/blink/renderer/platform/wtf/text/string_builder.h"

namespace blink {

SVGTransform::SVGTransform()
    : transform_type_(kSvgTransformUnknown), angle_(0) {}

SVGTransform::SVGTransform(SVGTransformType transform_type,
                           ConstructionMode mode)
    : transform_type_(transform_type), angle_(0) {
  if (mode == kConstructZeroTransform)
    matrix_ = AffineTransform(0, 0, 0, 0, 0, 0);
}

SVGTransform::SVGTransform(const AffineTransform& matrix)
    : transform_type_(kSvgTransformMatrix), angle_(0), matrix_(matrix) {}

SVGTransform::SVGTransform(SVGTransformType transform_type,
                           float angle,
                           const FloatPoint& center,
                           const AffineTransform& matrix)
    : transform_type_(transform_type),
      angle_(angle),
      center_(center),
      matrix_(matrix) {}

SVGTransform::~SVGTransform() = default;

SVGTransform* SVGTransform::Clone() const {
  return MakeGarbageCollected<SVGTransform>(transform_type_, angle_, center_,
                                            matrix_);
}

SVGPropertyBase* SVGTransform::CloneForAnimation(const String&) const {
  // SVGTransform is never animated.
  NOTREACHED();
  return nullptr;
}

void SVGTransform::SetMatrix(const AffineTransform& matrix) {
  OnMatrixChange();
  matrix_ = matrix;
}

void SVGTransform::OnMatrixChange() {
  transform_type_ = kSvgTransformMatrix;
  angle_ = 0;
}

void SVGTransform::SetTranslate(float tx, float ty) {
  transform_type_ = kSvgTransformTranslate;
  angle_ = 0;

  matrix_.MakeIdentity();
  matrix_.Translate(tx, ty);
}

FloatPoint SVGTransform::Translate() const {
  return FloatPoint::NarrowPrecision(matrix_.E(), matrix_.F());
}

void SVGTransform::SetScale(float sx, float sy) {
  transform_type_ = kSvgTransformScale;
  angle_ = 0;
  center_ = FloatPoint();

  matrix_.MakeIdentity();
  matrix_.ScaleNonUniform(sx, sy);
}

FloatSize SVGTransform::Scale() const {
  return FloatSize::NarrowPrecision(matrix_.A(), matrix_.D());
}

void SVGTransform::SetRotate(float angle, float cx, float cy) {
  transform_type_ = kSvgTransformRotate;
  angle_ = angle;
  center_ = FloatPoint(cx, cy);

  // TODO: toString() implementation, which can show cx, cy (need to be stored?)
  matrix_.MakeIdentity();
  matrix_.Translate(cx, cy);
  matrix_.Rotate(angle);
  matrix_.Translate(-cx, -cy);
}

void SVGTransform::SetSkewX(float angle) {
  transform_type_ = kSvgTransformSkewx;
  angle_ = angle;

  matrix_.MakeIdentity();
  matrix_.SkewX(angle);
}

void SVGTransform::SetSkewY(float angle) {
  transform_type_ = kSvgTransformSkewy;
  angle_ = angle;

  matrix_.MakeIdentity();
  matrix_.SkewY(angle);
}

namespace {

const char* TransformTypePrefixForParsing(SVGTransformType type) {
  switch (type) {
    case kSvgTransformUnknown:
      return "";
    case kSvgTransformMatrix:
      return "matrix(";
    case kSvgTransformTranslate:
      return "translate(";
    case kSvgTransformScale:
      return "scale(";
    case kSvgTransformRotate:
      return "rotate(";
    case kSvgTransformSkewx:
      return "skewX(";
    case kSvgTransformSkewy:
      return "skewY(";
  }
  NOTREACHED();
  return "";
}

}  // namespace

String SVGTransform::ValueAsString() const {
  double arguments[6];
  size_t argument_count = 0;
  switch (transform_type_) {
    case kSvgTransformUnknown:
      return g_empty_string;
    case kSvgTransformMatrix: {
      arguments[argument_count++] = matrix_.A();
      arguments[argument_count++] = matrix_.B();
      arguments[argument_count++] = matrix_.C();
      arguments[argument_count++] = matrix_.D();
      arguments[argument_count++] = matrix_.E();
      arguments[argument_count++] = matrix_.F();
      break;
    }
    case kSvgTransformTranslate: {
      arguments[argument_count++] = matrix_.E();
      arguments[argument_count++] = matrix_.F();
      break;
    }
    case kSvgTransformScale: {
      arguments[argument_count++] = matrix_.A();
      arguments[argument_count++] = matrix_.D();
      break;
    }
    case kSvgTransformRotate: {
      arguments[argument_count++] = angle_;

      double angle_in_rad = deg2rad(angle_);
      double cos_angle = cos(angle_in_rad);
      double sin_angle = sin(angle_in_rad);
      float cx = clampTo<float>(
          cos_angle != 1
              ? (matrix_.E() * (1 - cos_angle) - matrix_.F() * sin_angle) /
                    (1 - cos_angle) / 2
              : 0);
      float cy = clampTo<float>(
          cos_angle != 1
              ? (matrix_.E() * sin_angle / (1 - cos_angle) + matrix_.F()) / 2
              : 0);
      if (cx || cy) {
        arguments[argument_count++] = cx;
        arguments[argument_count++] = cy;
      }
      break;
    }
    case kSvgTransformSkewx:
      arguments[argument_count++] = angle_;
      break;
    case kSvgTransformSkewy:
      arguments[argument_count++] = angle_;
      break;
  }
  DCHECK_LE(argument_count, base::size(arguments));

  StringBuilder builder;
  builder.Append(TransformTypePrefixForParsing(transform_type_));

  for (size_t i = 0; i < argument_count; ++i) {
    if (i)
      builder.Append(' ');
    builder.AppendNumber(arguments[i]);
  }
  builder.Append(')');
  return builder.ToString();
}

void SVGTransform::Add(SVGPropertyBase*, SVGElement*) {
  // SVGTransform is not animated by itself.
  NOTREACHED();
}

void SVGTransform::CalculateAnimatedValue(SVGAnimationElement*,
                                          float,
                                          unsigned,
                                          SVGPropertyBase*,
                                          SVGPropertyBase*,
                                          SVGPropertyBase*,
                                          SVGElement*) {
  // SVGTransform is not animated by itself.
  NOTREACHED();
}

float SVGTransform::CalculateDistance(SVGPropertyBase*, SVGElement*) {
  // SVGTransform is not animated by itself.
  NOTREACHED();

  return -1;
}

}  // namespace blink