chromium/ui/gfx/geometry/transform_operations.cc

// Copyright 2013 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "ui/gfx/geometry/transform_operations.h"

#include <stddef.h>

#include <algorithm>
#include <utility>

#include "base/numerics/angle_conversions.h"
#include "ui/gfx/geometry/box_f.h"
#include "ui/gfx/geometry/transform_util.h"
#include "ui/gfx/geometry/vector3d_f.h"

namespace gfx {

TransformOperations::TransformOperations() = default;

TransformOperations::TransformOperations(const TransformOperations& other) { … }

TransformOperations::~TransformOperations() = default;

TransformOperations& TransformOperations::operator=(
    const TransformOperations& other) { … }

Transform TransformOperations::Apply() const { … }

Transform TransformOperations::ApplyRemaining(size_t start) const { … }

// TODO(crbug.com/41431421): Consolidate blink and cc implementations of
// transform interpolation.
TransformOperations TransformOperations::Blend(const TransformOperations& from,
                                               SkScalar progress) const { … }

bool TransformOperations::BlendedBoundsForBox(const BoxF& box,
                                              const TransformOperations& from,
                                              SkScalar min_progress,
                                              SkScalar max_progress,
                                              BoxF* bounds) const { … }

bool TransformOperations::PreservesAxisAlignment() const { … }

bool TransformOperations::IsTranslation() const { … }

static SkScalar TanDegrees(double degrees) { … }

bool TransformOperations::ScaleComponent(SkScalar* scale) const { … }

bool TransformOperations::MatchesTypes(const TransformOperations& other) const { … }

size_t TransformOperations::MatchingPrefixLength(
    const TransformOperations& other) const { … }

bool TransformOperations::CanBlendWith(const TransformOperations& other) const { … }

void TransformOperations::AppendTranslate(SkScalar x, SkScalar y, SkScalar z) { … }

void TransformOperations::AppendRotate(SkScalar x,
                                       SkScalar y,
                                       SkScalar z,
                                       SkScalar degrees) { … }

void TransformOperations::AppendScale(SkScalar x, SkScalar y, SkScalar z) { … }

void TransformOperations::AppendSkewX(SkScalar x) { … }

void TransformOperations::AppendSkewY(SkScalar y) { … }

void TransformOperations::AppendSkew(SkScalar x, SkScalar y) { … }

void TransformOperations::AppendPerspective(std::optional<SkScalar> depth) { … }

void TransformOperations::AppendMatrix(const Transform& matrix) { … }

void TransformOperations::AppendIdentity() { … }

void TransformOperations::Append(const TransformOperation& operation) { … }

bool TransformOperations::IsIdentity() const { … }

bool TransformOperations::ApproximatelyEqual(const TransformOperations& other,
                                             SkScalar tolerance) const { … }

bool TransformOperations::BlendInternal(const TransformOperations& from,
                                        SkScalar progress,
                                        TransformOperations* result) const { … }

bool TransformOperations::ComputeDecomposedTransform(
    size_t start_offset) const { … }

}  // namespace gfx