dom/base/DOMMatrix.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "mozilla/dom/BindingUtils.h"
   7 #include "mozilla/dom/DOMMatrixBinding.h"
   8 #include "mozilla/dom/DOMPointBinding.h"
   9 #include "mozilla/dom/BindingDeclarations.h"
  10 #include "mozilla/dom/ToJSValue.h"
  11
  12 #include "mozilla/dom/DOMPoint.h"
  13 #include "mozilla/dom/DOMMatrix.h"
  14
  15 #include "SVGTransformListParser.h"
  16 #include "SVGTransform.h"
  17
  18 #include "nsAutoPtr.h"
  19 #include <math.h>
  20
  21 namespace mozilla {
  22 namespace dom {
  23
  24 static const double radPerDegree = 2.0 * M_PI / 360.0;
  25
  26 already_AddRefed<DOMMatrix>
  27 DOMMatrixReadOnly::Translate(double aTx,
  28                              double aTy,
  29                              double aTz) const
  30 {
  31   nsRefPtr<DOMMatrix> retval = new DOMMatrix(mParent, *this);
  32   retval->TranslateSelf(aTx, aTy, aTz);
  33
  34   return retval.forget();
  35 }
  36
  37 already_AddRefed<DOMMatrix>
  38 DOMMatrixReadOnly::Scale(double aScale,
  39                          double aOriginX,
  40                          double aOriginY) const
  41 {
  42   nsRefPtr<DOMMatrix> retval = new DOMMatrix(mParent, *this);
  43   retval->ScaleSelf(aScale, aOriginX, aOriginY);
  44
  45   return retval.forget();
  46 }
  47
  48 already_AddRefed<DOMMatrix>
  49 DOMMatrixReadOnly::Scale3d(double aScale,
  50                            double aOriginX,
  51                            double aOriginY,
  52                            double aOriginZ) const
  53 {
  54   nsRefPtr<DOMMatrix> retval = new DOMMatrix(mParent, *this);
  55   retval->Scale3dSelf(aScale, aOriginX, aOriginY, aOriginZ);
  56
  57   return retval.forget();
  58 }
  59
  60 already_AddRefed<DOMMatrix>
  61 DOMMatrixReadOnly::ScaleNonUniform(double aScaleX,
  62                                    double aScaleY,
  63                                    double aScaleZ,
  64                                    double aOriginX,
  65                                    double aOriginY,
  66                                    double aOriginZ) const
  67 {
  68   nsRefPtr<DOMMatrix> retval = new DOMMatrix(mParent, *this);
  69   retval->ScaleNonUniformSelf(aScaleX, aScaleY, aScaleZ, aOriginX, aOriginY, aOriginZ);
  70
  71   return retval.forget();
  72 }
  73
  74 already_AddRefed<DOMMatrix>
  75 DOMMatrixReadOnly::Rotate(double aAngle,
  76                           double aOriginX ,
  77                           double aOriginY) const
  78 {
  79   nsRefPtr<DOMMatrix> retval = new DOMMatrix(mParent, *this);
  80   retval->RotateSelf(aAngle, aOriginX, aOriginY);
  81
  82   return retval.forget();
  83 }
  84
  85 already_AddRefed<DOMMatrix>
  86 DOMMatrixReadOnly::RotateFromVector(double x,
  87                                     double y) const
  88 {
  89   nsRefPtr<DOMMatrix> retval = new DOMMatrix(mParent, *this);
  90   retval->RotateFromVectorSelf(x, y);
  91
  92   return retval.forget();
  93 }
  94
  95 already_AddRefed<DOMMatrix>
  96 DOMMatrixReadOnly::RotateAxisAngle(double aX,
  97                                    double aY,
  98                                    double aZ,
  99                                    double aAngle) const
 100 {
 101   nsRefPtr<DOMMatrix> retval = new DOMMatrix(mParent, *this);
 102   retval->RotateAxisAngleSelf(aX, aY, aZ, aAngle);
 103
 104   return retval.forget();
 105 }
 106
 107 already_AddRefed<DOMMatrix>
 108 DOMMatrixReadOnly::SkewX(double aSx) const
 109 {
 110   nsRefPtr<DOMMatrix> retval = new DOMMatrix(mParent, *this);
 111   retval->SkewXSelf(aSx);
 112
 113   return retval.forget();
 114 }
 115
 116 already_AddRefed<DOMMatrix>
 117 DOMMatrixReadOnly::SkewY(double aSy) const
 118 {
 119   nsRefPtr<DOMMatrix> retval = new DOMMatrix(mParent, *this);
 120   retval->SkewYSelf(aSy);
 121
 122   return retval.forget();
 123 }
 124
 125 already_AddRefed<DOMMatrix>
 126 DOMMatrixReadOnly::Multiply(const DOMMatrix& other) const
 127 {
 128   nsRefPtr<DOMMatrix> retval = new DOMMatrix(mParent, *this);
 129   retval->MultiplySelf(other);
 130
 131   return retval.forget();
 132 }
 133
 134 already_AddRefed<DOMMatrix>
 135 DOMMatrixReadOnly::FlipX() const
 136 {
 137   nsRefPtr<DOMMatrix> retval = new DOMMatrix(mParent, *this);
 138   if (mMatrix3D) {
 139     gfx::Matrix4x4 m;
 140     m._11 = -1;
 141     retval->mMatrix3D = new gfx::Matrix4x4(m * *mMatrix3D);
 142   } else {
 143     gfx::Matrix m;
 144     m._11 = -1;
 145     retval->mMatrix2D = new gfx::Matrix(mMatrix2D ? m * *mMatrix2D : m);
 146   }
 147
 148   return retval.forget();
 149 }
 150
 151 already_AddRefed<DOMMatrix>
 152 DOMMatrixReadOnly::FlipY() const
 153 {
 154   nsRefPtr<DOMMatrix> retval = new DOMMatrix(mParent, *this);
 155   if (mMatrix3D) {
 156     gfx::Matrix4x4 m;
 157     m._22 = -1;
 158     retval->mMatrix3D = new gfx::Matrix4x4(m * *mMatrix3D);
 159   } else {
 160     gfx::Matrix m;
 161     m._22 = -1;
 162     retval->mMatrix2D = new gfx::Matrix(mMatrix2D ? m * *mMatrix2D : m);
 163   }
 164
 165   return retval.forget();
 166 }
 167
 168 already_AddRefed<DOMMatrix>
 169 DOMMatrixReadOnly::Inverse() const
 170 {
 171   nsRefPtr<DOMMatrix> retval = new DOMMatrix(mParent, *this);
 172   retval->InvertSelf();
 173
 174   return retval.forget();
 175 }
 176
 177 bool
 178 DOMMatrixReadOnly::Is2D() const
 179 {
 180   return !mMatrix3D;
 181 }
 182
 183 bool
 184 DOMMatrixReadOnly::Identity() const
 185 {
 186   if (mMatrix3D) {
 187     return mMatrix3D->IsIdentity();
 188   }
 189
 190   return mMatrix2D->IsIdentity();
 191 }
 192
 193 already_AddRefed<DOMPoint>
 194 DOMMatrixReadOnly::TransformPoint(const DOMPointInit& point) const
 195 {
 196   nsRefPtr<DOMPoint> retval = new DOMPoint(mParent);
 197
 198   if (mMatrix3D) {
 199     gfx::Point4D transformedPoint;
 200     transformedPoint.x = point.mX;
 201     transformedPoint.y = point.mY;
 202     transformedPoint.z = point.mZ;
 203     transformedPoint.w = point.mW;
 204
 205     transformedPoint = *mMatrix3D * transformedPoint;
 206
 207     retval->SetX(transformedPoint.x);
 208     retval->SetY(transformedPoint.y);
 209     retval->SetZ(transformedPoint.z);
 210     retval->SetW(transformedPoint.w);
 211   } else if (point.mZ != 0 || point.mW != 1.0) {
 212     gfx::Matrix4x4 tempMatrix(gfx::Matrix4x4::From2D(*mMatrix2D));
 213
 214     gfx::Point4D transformedPoint;
 215     transformedPoint.x = point.mX;
 216     transformedPoint.y = point.mY;
 217     transformedPoint.z = point.mZ;
 218     transformedPoint.w = point.mW;
 219
 220     transformedPoint = tempMatrix * transformedPoint;
 221
 222     retval->SetX(transformedPoint.x);
 223     retval->SetY(transformedPoint.y);
 224     retval->SetZ(transformedPoint.z);
 225     retval->SetW(transformedPoint.w);
 226   } else {
 227     gfx::Point transformedPoint;
 228     transformedPoint.x = point.mX;
 229     transformedPoint.y = point.mY;
 230
 231     transformedPoint = *mMatrix2D * transformedPoint;
 232
 233     retval->SetX(transformedPoint.x);
 234     retval->SetY(transformedPoint.y);
 235     retval->SetZ(point.mZ);
 236     retval->SetW(point.mW);
 237   }
 238   return retval.forget();
 239 }
 240
 241 template <typename T> void GetDataFromMatrix(const DOMMatrixReadOnly* aMatrix, T* aData)
 242 {
 243   aData[0] = static_cast<T>(aMatrix->M11());
 244   aData[1] = static_cast<T>(aMatrix->M12());
 245   aData[2] = static_cast<T>(aMatrix->M13());
 246   aData[3] = static_cast<T>(aMatrix->M14());
 247   aData[4] = static_cast<T>(aMatrix->M21());
 248   aData[5] = static_cast<T>(aMatrix->M22());
 249   aData[6] = static_cast<T>(aMatrix->M23());
 250   aData[7] = static_cast<T>(aMatrix->M24());
 251   aData[8] = static_cast<T>(aMatrix->M31());
 252   aData[9] = static_cast<T>(aMatrix->M32());
 253   aData[10] = static_cast<T>(aMatrix->M33());
 254   aData[11] = static_cast<T>(aMatrix->M34());
 255   aData[12] = static_cast<T>(aMatrix->M41());
 256   aData[13] = static_cast<T>(aMatrix->M42());
 257   aData[14] = static_cast<T>(aMatrix->M43());
 258   aData[15] = static_cast<T>(aMatrix->M44());
 259 }
 260
 261 void
 262 DOMMatrixReadOnly::ToFloat32Array(JSContext* aCx, JS::MutableHandle<JSObject*> aResult, ErrorResult& aRv) const
 263 {
 264   nsAutoTArray<float, 16> arr;
 265   arr.SetLength(16);
 266   GetDataFromMatrix(this, arr.Elements());
 267   JS::Rooted<JS::Value> value(aCx);
 268   if (!ToJSValue(aCx, TypedArrayCreator<Float32Array>(arr), &value)) {
 269     aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
 270     return;
 271   }
 272   aResult.set(&value.toObject());
 273 }
 274
 275 void
 276 DOMMatrixReadOnly::ToFloat64Array(JSContext* aCx, JS::MutableHandle<JSObject*> aResult, ErrorResult& aRv) const
 277 {
 278   nsAutoTArray<double, 16> arr;
 279   arr.SetLength(16);
 280   GetDataFromMatrix(this, arr.Elements());
 281   JS::Rooted<JS::Value> value(aCx);
 282   if (!ToJSValue(aCx, TypedArrayCreator<Float64Array>(arr), &value)) {
 283     aRv.Throw(NS_ERROR_OUT_OF_MEMORY);
 284     return;
 285   }
 286   aResult.set(&value.toObject());
 287 }
 288
 289 void
 290 DOMMatrixReadOnly::Stringify(nsAString& aResult)
 291 {
 292   nsAutoString matrixStr;
 293   if (mMatrix3D) {
 294     matrixStr.AppendPrintf("matrix3d(%g, %g, %g, %g, %g, %g, %g, %g, %g, %g, %g, %g, %g, %g, %g, %g)",
 295       M11(), M12(), M13(), M14(),
 296       M21(), M22(), M23(), M24(),
 297       M31(), M32(), M33(), M34(),
 298       M41(), M42(), M43(), M44());
 299   } else {
 300     matrixStr.AppendPrintf("matrix(%g, %g, %g, %g, %g, %g)", A(), B(), C(), D(), E(), F());
 301   }
 302
 303   aResult = matrixStr;
 304 }
 305
 306 NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE(DOMMatrix, mParent)
 307
 308 NS_IMPL_CYCLE_COLLECTION_ROOT_NATIVE(DOMMatrix, AddRef)
 309 NS_IMPL_CYCLE_COLLECTION_UNROOT_NATIVE(DOMMatrix, Release)
 310
 311 already_AddRefed<DOMMatrix>
 312 DOMMatrix::Constructor(const GlobalObject& aGlobal, ErrorResult& aRv)
 313 {
 314   nsRefPtr<DOMMatrix> obj = new DOMMatrix(aGlobal.GetAsSupports());
 315   return obj.forget();
 316 }
 317
 318 already_AddRefed<DOMMatrix>
 319 DOMMatrix::Constructor(const GlobalObject& aGlobal, const nsAString& aTransformList, ErrorResult& aRv)
 320 {
 321   nsRefPtr<DOMMatrix> obj = new DOMMatrix(aGlobal.GetAsSupports());
 322
 323   obj = obj->SetMatrixValue(aTransformList, aRv);
 324   return obj.forget();
 325 }
 326
 327 already_AddRefed<DOMMatrix>
 328 DOMMatrix::Constructor(const GlobalObject& aGlobal, const DOMMatrixReadOnly& aOther, ErrorResult& aRv)
 329 {
 330   nsRefPtr<DOMMatrix> obj = new DOMMatrix(aGlobal.GetAsSupports(), aOther);
 331   return obj.forget();
 332 }
 333
 334 template <typename T> void SetDataInMatrix(DOMMatrix* aMatrix, const T* aData, int aLength, ErrorResult& aRv)
 335 {
 336   if (aLength == 16) {
 337     aMatrix->SetM11(aData[0]);
 338     aMatrix->SetM12(aData[1]);
 339     aMatrix->SetM13(aData[2]);
 340     aMatrix->SetM14(aData[3]);
 341     aMatrix->SetM21(aData[4]);
 342     aMatrix->SetM22(aData[5]);
 343     aMatrix->SetM23(aData[6]);
 344     aMatrix->SetM24(aData[7]);
 345     aMatrix->SetM31(aData[8]);
 346     aMatrix->SetM32(aData[9]);
 347     aMatrix->SetM33(aData[10]);
 348     aMatrix->SetM34(aData[11]);
 349     aMatrix->SetM41(aData[12]);
 350     aMatrix->SetM42(aData[13]);
 351     aMatrix->SetM43(aData[14]);
 352     aMatrix->SetM44(aData[15]);
 353   } else if (aLength == 6) {
 354     aMatrix->SetA(aData[0]);
 355     aMatrix->SetB(aData[1]);
 356     aMatrix->SetC(aData[2]);
 357     aMatrix->SetD(aData[3]);
 358     aMatrix->SetE(aData[4]);
 359     aMatrix->SetF(aData[5]);
 360   } else {
 361     aRv.Throw(NS_ERROR_DOM_INDEX_SIZE_ERR);
 362   }
 363 }
 364
 365 already_AddRefed<DOMMatrix>
 366 DOMMatrix::Constructor(const GlobalObject& aGlobal, const Float32Array& aArray32, ErrorResult& aRv)
 367 {
 368   nsRefPtr<DOMMatrix> obj = new DOMMatrix(aGlobal.GetAsSupports());
 369   aArray32.ComputeLengthAndData();
 370   SetDataInMatrix(obj, aArray32.Data(), aArray32.Length(), aRv);
 371
 372   return obj.forget();
 373 }
 374
 375 already_AddRefed<DOMMatrix>
 376 DOMMatrix::Constructor(const GlobalObject& aGlobal, const Float64Array& aArray64, ErrorResult& aRv)
 377 {
 378   nsRefPtr<DOMMatrix> obj = new DOMMatrix(aGlobal.GetAsSupports());
 379   aArray64.ComputeLengthAndData();
 380   SetDataInMatrix(obj, aArray64.Data(), aArray64.Length(), aRv);
 381
 382   return obj.forget();
 383 }
 384
 385 already_AddRefed<DOMMatrix>
 386 DOMMatrix::Constructor(const GlobalObject& aGlobal, const Sequence<double>& aNumberSequence, ErrorResult& aRv)
 387 {
 388   nsRefPtr<DOMMatrix> obj = new DOMMatrix(aGlobal.GetAsSupports());
 389   SetDataInMatrix(obj, aNumberSequence.Elements(), aNumberSequence.Length(), aRv);
 390
 391   return obj.forget();
 392 }
 393
 394 void DOMMatrix::Ensure3DMatrix()
 395 {
 396   if (!mMatrix3D) {
 397     mMatrix3D = new gfx::Matrix4x4(gfx::Matrix4x4::From2D(*mMatrix2D));
 398     mMatrix2D = nullptr;
 399   }
 400 }
 401
 402 DOMMatrix*
 403 DOMMatrix::MultiplySelf(const DOMMatrix& aOther)
 404 {
 405   if (aOther.Identity()) {
 406     return this;
 407   }
 408
 409   if (aOther.Is2D()) {
 410     if (mMatrix3D) {
 411       *mMatrix3D = gfx::Matrix4x4::From2D(*aOther.mMatrix2D) * *mMatrix3D;
 412     } else {
 413       *mMatrix2D = *aOther.mMatrix2D * *mMatrix2D;
 414     }
 415   } else {
 416     Ensure3DMatrix();
 417     *mMatrix3D = *aOther.mMatrix3D * *mMatrix3D;
 418   }
 419
 420   return this;
 421 }
 422
 423 DOMMatrix*
 424 DOMMatrix::PreMultiplySelf(const DOMMatrix& aOther)
 425 {
 426   if (aOther.Identity()) {
 427     return this;
 428   }
 429
 430   if (aOther.Is2D()) {
 431     if (mMatrix3D) {
 432       *mMatrix3D = *mMatrix3D * gfx::Matrix4x4::From2D(*aOther.mMatrix2D);
 433     } else {
 434       *mMatrix2D = *mMatrix2D * *aOther.mMatrix2D;
 435     }
 436   } else {
 437     Ensure3DMatrix();
 438     *mMatrix3D = *mMatrix3D * *aOther.mMatrix3D;
 439   }
 440
 441   return this;
 442 }
 443
 444 DOMMatrix*
 445 DOMMatrix::TranslateSelf(double aTx,
 446                          double aTy,
 447                          double aTz)
 448 {
 449   if (aTx == 0 && aTy == 0 && aTz == 0) {
 450     return this;
 451   }
 452
 453   if (mMatrix3D || aTz != 0) {
 454     Ensure3DMatrix();
 455     mMatrix3D->PreTranslate(aTx, aTy, aTz);
 456   } else {
 457     mMatrix2D->PreTranslate(aTx, aTy);
 458   }
 459
 460   return this;
 461 }
 462
 463 DOMMatrix*
 464 DOMMatrix::ScaleSelf(double aScale, double aOriginX, double aOriginY)
 465 {
 466   ScaleNonUniformSelf(aScale, aScale, 1.0, aOriginX, aOriginY, 0);
 467
 468   return this;
 469 }
 470
 471 DOMMatrix*
 472 DOMMatrix::Scale3dSelf(double aScale, double aOriginX,
 473                        double aOriginY, double aOriginZ)
 474 {
 475   ScaleNonUniformSelf(aScale, aScale, aScale, aOriginX, aOriginY, aOriginZ);
 476
 477   return this;
 478 }
 479
 480 DOMMatrix*
 481 DOMMatrix::ScaleNonUniformSelf(double aScaleX,
 482                                double aScaleY,
 483                                double aScaleZ,
 484                                double aOriginX,
 485                                double aOriginY,
 486                                double aOriginZ)
 487 {
 488   if (aScaleX == 1.0 && aScaleY == 1.0 && aScaleZ == 1.0) {
 489     return this;
 490   }
 491
 492   TranslateSelf(aOriginX, aOriginY, aOriginZ);
 493
 494   if (mMatrix3D || aScaleZ != 1.0 || aOriginZ != 0) {
 495     Ensure3DMatrix();
 496     gfx::Matrix4x4 m;
 497     m._11 = aScaleX;
 498     m._22 = aScaleY;
 499     m._33 = aScaleZ;
 500     *mMatrix3D = m * *mMatrix3D;
 501   } else {
 502     gfx::Matrix m;
 503     m._11 = aScaleX;
 504     m._22 = aScaleY;
 505     *mMatrix2D = m * *mMatrix2D;
 506   }
 507
 508   TranslateSelf(-aOriginX, -aOriginY, -aOriginZ);
 509
 510   return this;
 511 }
 512
 513 DOMMatrix*
 514 DOMMatrix::RotateFromVectorSelf(double aX, double aY)
 515 {
 516   if (aX == 0.0 || aY == 0.0) {
 517     return this;
 518   }
 519
 520   RotateSelf(atan2(aY, aX) / radPerDegree);
 521
 522   return this;
 523 }
 524
 525 DOMMatrix*
 526 DOMMatrix::RotateSelf(double aAngle, double aOriginX, double aOriginY)
 527 {
 528   if (fmod(aAngle, 360) == 0) {
 529     return this;
 530   }
 531
 532   TranslateSelf(aOriginX, aOriginY);
 533
 534   if (mMatrix3D) {
 535     RotateAxisAngleSelf(0, 0, 1, aAngle);
 536   } else {
 537     *mMatrix2D = mMatrix2D->PreRotate(aAngle * radPerDegree);
 538   }
 539
 540   TranslateSelf(-aOriginX, -aOriginY);
 541
 542   return this;
 543 }
 544
 545 DOMMatrix*
 546 DOMMatrix::RotateAxisAngleSelf(double aX, double aY,
 547                                double aZ, double aAngle)
 548 {
 549   if (fmod(aAngle, 360) == 0) {
 550     return this;
 551   }
 552
 553   aAngle *= radPerDegree;
 554   // sin(aAngle / 2) * cos(aAngle / 2)
 555   double sc = sin(aAngle) / 2;
 556   // pow(sin(aAngle / 2), 2)
 557   double sq = (1 - cos(aAngle)) / 2;
 558
 559   Ensure3DMatrix();
 560   gfx::Matrix4x4 m;
 561   m._11 = 1 - 2 * (aY * aY + aZ * aZ) * sq;
 562   m._12 = 2 * (aX * aY * sq + aZ * sc);
 563   m._13 = 2 * (aX * aZ * sq - aY * sc);
 564   m._21 = 2 * (aX * aY * sq - aZ * sc);
 565   m._22 = 1 - 2 * (aX * aX + aZ * aZ) * sq;
 566   m._23 = 2 * (aY * aZ * sq + aX * sc);
 567   m._31 = 2 * (aX * aZ * sq + aY * sc);
 568   m._32 = 2 * (aY * aZ * sq - aX * sc);
 569   m._33 = 1 - 2 * (aX * aX + aY * aY) * sq;
 570
 571   *mMatrix3D = m * *mMatrix3D;
 572
 573   return this;
 574 }
 575
 576 DOMMatrix*
 577 DOMMatrix::SkewXSelf(double aSx)
 578 {
 579   if (fmod(aSx, 360) == 0) {
 580     return this;
 581   }
 582
 583   if (mMatrix3D) {
 584     gfx::Matrix4x4 m;
 585     m._21 = tan(aSx * radPerDegree);
 586     *mMatrix3D = m * *mMatrix3D;
 587   } else {
 588     gfx::Matrix m;
 589     m._21 = tan(aSx * radPerDegree);
 590     *mMatrix2D = m * *mMatrix2D;
 591   }
 592
 593   return this;
 594 }
 595
 596 DOMMatrix*
 597 DOMMatrix::SkewYSelf(double aSy)
 598 {
 599   if (fmod(aSy, 360) == 0) {
 600     return this;
 601   }
 602
 603   if (mMatrix3D) {
 604     gfx::Matrix4x4 m;
 605     m._12 = tan(aSy * radPerDegree);
 606     *mMatrix3D = m * *mMatrix3D;
 607   } else {
 608     gfx::Matrix m;
 609     m._12 = tan(aSy * radPerDegree);
 610     *mMatrix2D = m * *mMatrix2D;
 611   }
 612
 613   return this;
 614 }
 615
 616 DOMMatrix*
 617 DOMMatrix::InvertSelf()
 618 {
 619   if (mMatrix3D) {
 620     if (!mMatrix3D->Invert()) {
 621       mMatrix3D->SetNAN();
 622     }
 623   } else if (!mMatrix2D->Invert()) {
 624     mMatrix2D = nullptr;
 625
 626     mMatrix3D = new gfx::Matrix4x4();
 627     mMatrix3D->SetNAN();
 628   }
 629
 630   return this;
 631 }
 632
 633 DOMMatrix*
 634 DOMMatrix::SetMatrixValue(const nsAString& aTransformList, ErrorResult& aRv)
 635 {
 636   SVGTransformListParser parser(aTransformList);
 637   if (!parser.Parse()) {
 638     aRv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
 639   } else {
 640     mMatrix3D = nullptr;
 641     mMatrix2D = new gfx::Matrix();
 642     gfxMatrix result;
 643     const nsTArray<nsSVGTransform>& mItems = parser.GetTransformList();
 644
 645     for (uint32_t i = 0; i < mItems.Length(); ++i) {
 646       result.PreMultiply(mItems[i].GetMatrix());
 647     }
 648
 649     SetA(result._11);
 650     SetB(result._12);
 651     SetC(result._21);
 652     SetD(result._22);
 653     SetE(result._31);
 654     SetF(result._32);
 655   }
 656
 657   return this;
 658 }
 659
 660 JSObject*
 661 DOMMatrix::WrapObject(JSContext* aCx)
 662 {
 663   return DOMMatrixBinding::Wrap(aCx, this);
 664 }
 665
 666 } // namespace dom
 667 } // namespace mozilla