dom_matrix_read_only.cc | Explore in Territory

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

#include "third_party/blink/renderer/core/geometry/dom_matrix_read_only.h"

#include "third_party/blink/renderer/bindings/core/v8/v8_dom_matrix_2d_init.h"
#include "third_party/blink/renderer/bindings/core/v8/v8_dom_matrix_init.h"
#include "third_party/blink/renderer/bindings/core/v8/v8_dom_point_init.h"
#include "third_party/blink/renderer/bindings/core/v8/v8_object_builder.h"
#include "third_party/blink/renderer/bindings/core/v8/v8_union_string_unrestricteddoublesequence.h"
#include "third_party/blink/renderer/core/css/css_identifier_value.h"
#include "third_party/blink/renderer/core/css/css_to_length_conversion_data.h"
#include "third_party/blink/renderer/core/css/css_value_list.h"
#include "third_party/blink/renderer/core/css/parser/css_parser.h"
#include "third_party/blink/renderer/core/css/resolver/transform_builder.h"
#include "third_party/blink/renderer/core/execution_context/execution_context.h"
#include "third_party/blink/renderer/core/geometry/dom_matrix.h"
#include "third_party/blink/renderer/core/geometry/dom_point.h"
#include "third_party/blink/renderer/core/layout/layout_view.h"
#include "third_party/blink/renderer/core/style/computed_style.h"

namespace blink {
namespace {

void SetDictionaryMembers(DOMMatrix2DInit* other) { … }

}  // namespace

bool DOMMatrixReadOnly::ValidateAndFixup2D(DOMMatrix2DInit* other) { … }

bool DOMMatrixReadOnly::ValidateAndFixup(DOMMatrixInit* other,
                                         ExceptionState& exception_state) { … }

DOMMatrixReadOnly* DOMMatrixReadOnly::Create(
    ExecutionContext* execution_context,
    ExceptionState& exception_state) { … }

DOMMatrixReadOnly* DOMMatrixReadOnly::Create(
    ExecutionContext* execution_context,
    const V8UnionStringOrUnrestrictedDoubleSequence* init,
    ExceptionState& exception_state) { … }

DOMMatrixReadOnly* DOMMatrixReadOnly::CreateForSerialization(double sequence[],
                                                             int size) { … }

DOMMatrixReadOnly* DOMMatrixReadOnly::fromFloat32Array(
    NotShared<DOMFloat32Array> float32_array,
    ExceptionState& exception_state) { … }

DOMMatrixReadOnly* DOMMatrixReadOnly::fromFloat64Array(
    NotShared<DOMFloat64Array> float64_array,
    ExceptionState& exception_state) { … }

DOMMatrixReadOnly* DOMMatrixReadOnly::fromMatrix2D(
    DOMMatrix2DInit* other,
    ExceptionState& exception_state) { … }

DOMMatrixReadOnly* DOMMatrixReadOnly::fromMatrix(
    DOMMatrixInit* other,
    ExceptionState& exception_state) { … }

DOMMatrixReadOnly::~DOMMatrixReadOnly() = default;

bool DOMMatrixReadOnly::is2D() const { … }

bool DOMMatrixReadOnly::isIdentity() const { … }

DOMMatrix* DOMMatrixReadOnly::multiply(DOMMatrixInit* other,
                                       ExceptionState& exception_state) { … }

DOMMatrix* DOMMatrixReadOnly::translate(double tx, double ty, double tz) { … }

DOMMatrix* DOMMatrixReadOnly::scale(double sx) { … }

DOMMatrix* DOMMatrixReadOnly::scale(double sx,
                                    double sy,
                                    double sz,
                                    double ox,
                                    double oy,
                                    double oz) { … }

DOMMatrix* DOMMatrixReadOnly::scale3d(double scale,
                                      double ox,
                                      double oy,
                                      double oz) { … }

DOMMatrix* DOMMatrixReadOnly::scaleNonUniform(double sx, double sy) { … }

DOMMatrix* DOMMatrixReadOnly::rotate(double rot_x) { … }

DOMMatrix* DOMMatrixReadOnly::rotate(double rot_x, double rot_y) { … }

DOMMatrix* DOMMatrixReadOnly::rotate(double rot_x, double rot_y, double rot_z) { … }

DOMMatrix* DOMMatrixReadOnly::rotateFromVector(double x, double y) { … }

DOMMatrix* DOMMatrixReadOnly::rotateAxisAngle(double x,
                                              double y,
                                              double z,
                                              double angle) { … }

DOMMatrix* DOMMatrixReadOnly::skewX(double sx) { … }

DOMMatrix* DOMMatrixReadOnly::skewY(double sy) { … }

DOMMatrix* DOMMatrixReadOnly::flipX() { … }

DOMMatrix* DOMMatrixReadOnly::flipY() { … }

DOMMatrix* DOMMatrixReadOnly::inverse() { … }

DOMPoint* DOMMatrixReadOnly::transformPoint(const DOMPointInit* point) { … }

DOMMatrixReadOnly::DOMMatrixReadOnly(const gfx::Transform& matrix, bool is2d)
    : … { … }

NotShared<DOMFloat32Array> DOMMatrixReadOnly::toFloat32Array() const { … }

NotShared<DOMFloat64Array> DOMMatrixReadOnly::toFloat64Array() const { … }

const String DOMMatrixReadOnly::toString(
    ExceptionState& exception_state) const { … }

ScriptValue DOMMatrixReadOnly::toJSONForBinding(
    ScriptState* script_state) const { … }

AffineTransform DOMMatrixReadOnly::GetAffineTransform() const { … }

void DOMMatrixReadOnly::SetMatrixValueFromString(
    const ExecutionContext* execution_context,
    const String& input_string,
    ExceptionState& exception_state) { … }

}  // namespace blink
chromium/third_party/blink/renderer/core/geometry/dom_matrix_read_only.cc
