2009-02-09 Chris Marrin <cmarrin@apple.com>
authorsimon.fraser@apple.com <simon.fraser@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 10 Feb 2009 05:22:08 +0000 (05:22 +0000)
committersimon.fraser@apple.com <simon.fraser@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 10 Feb 2009 05:22:08 +0000 (05:22 +0000)
        Reviewed by Simon Fraser

        https://bugs.webkit.org/show_bug.cgi?id=23689

        Added 3D functions to WebKitCSSMatrix. This depends on the 3D functions
        added to TransformationMatrix in https://bugs.webkit.org/show_bug.cgi?id=6868

        Test: transforms/3d/cssmatrix-3d-interface.xhtml

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@40807 268f45cc-cd09-0410-ab3c-d52691b4dbfc

LayoutTests/ChangeLog
LayoutTests/transforms/2d/cssmatrix-interface-expected.txt
LayoutTests/transforms/2d/cssmatrix-interface.xhtml
WebCore/ChangeLog
WebCore/css/WebKitCSSMatrix.cpp
WebCore/css/WebKitCSSMatrix.h
WebCore/css/WebKitCSSMatrix.idl

index 0e4844f..8dca6e9 100644 (file)
@@ -1,3 +1,15 @@
+2009-02-09  Chris Marrin  <cmarrin@apple.com>
+
+        Reviewed by Simon Fraser
+
+        https://bugs.webkit.org/show_bug.cgi?id=23689
+
+        Add test for 3D functionality of WebKitCSSMatrix.
+
+        * transforms/3d: Added.
+        * transforms/3d/cssmatrix-3d-interface-expected.txt: Added.
+        * transforms/3d/cssmatrix-3d-interface.xhtml: Added.
+
 2009-02-09  Mark Rowe  <mrowe@apple.com>
 
         Reviewed by Sam Weinig.
index 8071346..2925456 100644 (file)
@@ -8,6 +8,16 @@ PASS default constructor
 PASS object constructor
 PASS string constructor
 
+Test toString
+PASS a[0] is "matrix"
+PASS parseFloat(a2[0]) is 1
+PASS parseFloat(a2[1]) is 0
+PASS parseFloat(a2[2]) is 0
+PASS parseFloat(a2[3]) is 1
+PASS parseFloat(a2[4]) is 0
+PASS parseFloat(a3[0]) is 0
+PASS a3[1] is ""
+
 Test bad input to string constructor
 PASS new WebKitCSSMatrix("banana") threw exception Error: SYNTAX_ERR: DOM Exception 12.
 
@@ -56,6 +66,17 @@ PASS parseFloat(m3.d) is 64
 PASS parseFloat(m3.e) is 100
 PASS parseFloat(m3.f) is 112
 
+Test multiply with missing argument
+PASS m2 is null
+
+Test immutability of multiply
+PASS parseFloat(m.a) is 1
+PASS parseFloat(m.b) is 2
+PASS parseFloat(m.c) is 3
+PASS parseFloat(m.d) is 4
+PASS parseFloat(m.e) is 5
+PASS parseFloat(m.f) is 6
+
 Test inverse
 PASS parseFloat(m2.a) is 0.5
 PASS parseFloat(m2.b) is 0
@@ -64,33 +85,65 @@ PASS parseFloat(m2.d) is 0.5
 PASS parseFloat(m2.e) is -5
 PASS parseFloat(m2.f) is -10
 
+Test immutability of inverse
+PASS parseFloat(m.a) is 2
+PASS parseFloat(m.b) is 0
+PASS parseFloat(m.c) is 0
+PASS parseFloat(m.d) is 2
+PASS parseFloat(m.e) is 10
+PASS parseFloat(m.f) is 20
+
 Test throwing exception from inverse
 PASS m.inverse() threw exception Error: NOT_SUPPORTED_ERR: DOM Exception 9.
 
 Test translate
-PASS m.a is 1
-PASS m.b is 0
-PASS m.c is 0
-PASS m.d is 1
-PASS m.e is 10
-PASS m.f is 20
+PASS m2.a is 1
+PASS m2.b is 0
+PASS m2.c is 0
+PASS m2.d is 1
+PASS m2.e is 10
+PASS m2.f is 20
+
+Test immutability of translate
+PASS parseFloat(m.a) is 1
+PASS parseFloat(m.b) is 0
+PASS parseFloat(m.c) is 0
+PASS parseFloat(m.d) is 1
+PASS parseFloat(m.e) is 0
+PASS parseFloat(m.f) is 0
 
 Test scale
-PASS m.a is 10
-PASS m.b is 0
-PASS m.c is 0
-PASS m.d is 20
-PASS m.e is 0
-PASS m.f is 0
+PASS m2.a is 10
+PASS m2.b is 0
+PASS m2.c is 0
+PASS m2.d is 20
+PASS m2.e is 0
+PASS m2.f is 0
+
+Test immutability of scale
+PASS parseFloat(m.a) is 1
+PASS parseFloat(m.b) is 0
+PASS parseFloat(m.c) is 0
+PASS parseFloat(m.d) is 1
+PASS parseFloat(m.e) is 0
+PASS parseFloat(m.f) is 0
 
 Test rotate
-PASS Math.round(m.a*1000000)/1000000 is 0.984808
-PASS Math.round(m.b*1000000)/1000000 is 0.173648
-PASS Math.round(m.c*1000000)/1000000 is -0.173648
-PASS Math.round(m.d*1000000)/1000000 is 0.984808
+PASS parseFloat(m2.a.toPrecision(6)) is 0.984808
+PASS parseFloat(m2.b.toPrecision(6)) is 0.173648
+PASS parseFloat(m2.c.toPrecision(6)) is -0.173648
+PASS parseFloat(m2.d.toPrecision(6)) is 0.984808
 PASS m.e is 0
 PASS m.f is 0
 
+Test immutability of rotate
+PASS parseFloat(m.a) is 1
+PASS parseFloat(m.b) is 0
+PASS parseFloat(m.c) is 0
+PASS parseFloat(m.d) is 1
+PASS parseFloat(m.e) is 0
+PASS parseFloat(m.f) is 0
+
 PASS successfullyParsed is true
 
 TEST COMPLETE
index 81fe6c9..b7714d7 100644 (file)
@@ -34,6 +34,22 @@ else
   testFailed("string constructor");
 
 debug("");
+debug("Test toString");
+var m = new WebKitCSSMatrix("matrix(1, 0, 0, 1, 0, 0)");
+var s = m.toString();
+var a = s.split('(');
+shouldBe('a[0]', '"matrix"');
+var a2 = a[1].split(',');
+shouldBe('parseFloat(a2[0])', '1');
+shouldBe('parseFloat(a2[1])', '0');
+shouldBe('parseFloat(a2[2])', '0');
+shouldBe('parseFloat(a2[3])', '1');
+shouldBe('parseFloat(a2[4])', '0');
+var a3 = a2[5].split(")");
+shouldBe('parseFloat(a3[0])', '0');
+shouldBe('a3[1]', '""');
+
+debug("");
 debug("Test bad input to string constructor");
 shouldThrow('new WebKitCSSMatrix("banana")');
 
@@ -98,6 +114,21 @@ shouldBe('parseFloat(m3.e)', '100');
 shouldBe('parseFloat(m3.f)', '112');
 
 debug("");
+debug("Test multiply with missing argument");
+m = new WebKitCSSMatrix("matrix(1, 2, 3, 4, 5, 6)");
+m2 = m.multiply();
+shouldBe('m2', 'null');
+
+debug("");
+debug("Test immutability of multiply");
+shouldBe('parseFloat(m.a)', '1');
+shouldBe('parseFloat(m.b)', '2');
+shouldBe('parseFloat(m.c)', '3');
+shouldBe('parseFloat(m.d)', '4');
+shouldBe('parseFloat(m.e)', '5');
+shouldBe('parseFloat(m.f)', '6');
+
+debug("");
 debug("Test inverse");
 m = new WebKitCSSMatrix("matrix(2, 0, 0, 2, 10, 20)");
 m2 = m.inverse();
@@ -110,6 +141,15 @@ shouldBe('parseFloat(m2.e)', '-5');
 shouldBe('parseFloat(m2.f)', '-10');
 
 debug("");
+debug("Test immutability of inverse");
+shouldBe('parseFloat(m.a)', '2');
+shouldBe('parseFloat(m.b)', '0');
+shouldBe('parseFloat(m.c)', '0');
+shouldBe('parseFloat(m.d)', '2');
+shouldBe('parseFloat(m.e)', '10');
+shouldBe('parseFloat(m.f)', '20');
+
+debug("");
 debug("Test throwing exception from inverse");
 m = new WebKitCSSMatrix("matrix(0, 0, 0, 0, 0, 0)"); // not invertible
 shouldThrow('m.inverse()');
@@ -117,37 +157,64 @@ shouldThrow('m.inverse()');
 debug("");
 debug("Test translate");
 m = new WebKitCSSMatrix();
-m = m.translate(10, 20);
-shouldBe('m.a', '1');
-shouldBe('m.b', '0');
-shouldBe('m.c', '0');
-shouldBe('m.d', '1');
-shouldBe('m.e', '10');
-shouldBe('m.f', '20');
+m2 = m.translate(10, 20);
+shouldBe('m2.a', '1');
+shouldBe('m2.b', '0');
+shouldBe('m2.c', '0');
+shouldBe('m2.d', '1');
+shouldBe('m2.e', '10');
+shouldBe('m2.f', '20');
+
+debug("");
+debug("Test immutability of translate");
+shouldBe('parseFloat(m.a)', '1');
+shouldBe('parseFloat(m.b)', '0');
+shouldBe('parseFloat(m.c)', '0');
+shouldBe('parseFloat(m.d)', '1');
+shouldBe('parseFloat(m.e)', '0');
+shouldBe('parseFloat(m.f)', '0');
 
 debug("");
 debug("Test scale");
 m = new WebKitCSSMatrix();
-m = m.scale(10, 20);
-shouldBe('m.a', '10');
-shouldBe('m.b', '0');
-shouldBe('m.c', '0');
-shouldBe('m.d', '20');
-shouldBe('m.e', '0');
-shouldBe('m.f', '0');
+m2 = m.scale(10, 20);
+shouldBe('m2.a', '10');
+shouldBe('m2.b', '0');
+shouldBe('m2.c', '0');
+shouldBe('m2.d', '20');
+shouldBe('m2.e', '0');
+shouldBe('m2.f', '0');
+
+debug("");
+debug("Test immutability of scale");
+shouldBe('parseFloat(m.a)', '1');
+shouldBe('parseFloat(m.b)', '0');
+shouldBe('parseFloat(m.c)', '0');
+shouldBe('parseFloat(m.d)', '1');
+shouldBe('parseFloat(m.e)', '0');
+shouldBe('parseFloat(m.f)', '0');
 
 debug("");
 debug("Test rotate");
 m = new WebKitCSSMatrix();
-m = m.rotate(10);
-shouldBe('Math.round(m.a*1000000)/1000000', '0.984808');
-shouldBe('Math.round(m.b*1000000)/1000000', '0.173648');
-shouldBe('Math.round(m.c*1000000)/1000000', '-0.173648');
-shouldBe('Math.round(m.d*1000000)/1000000', '0.984808');
+m2 = m.rotate(10);
+shouldBe('parseFloat(m2.a.toPrecision(6))', '0.984808');
+shouldBe('parseFloat(m2.b.toPrecision(6))', '0.173648');
+shouldBe('parseFloat(m2.c.toPrecision(6))', '-0.173648');
+shouldBe('parseFloat(m2.d.toPrecision(6))', '0.984808');
 shouldBe('m.e', '0');
 shouldBe('m.f', '0');
 
 debug("");
+debug("Test immutability of rotate");
+shouldBe('parseFloat(m.a)', '1');
+shouldBe('parseFloat(m.b)', '0');
+shouldBe('parseFloat(m.c)', '0');
+shouldBe('parseFloat(m.d)', '1');
+shouldBe('parseFloat(m.e)', '0');
+shouldBe('parseFloat(m.f)', '0');
+
+debug("");
 successfullyParsed = true;
 
 </script>
index 20b4d49..2a4d18b 100644 (file)
@@ -1,3 +1,18 @@
+2009-02-09  Chris Marrin  <cmarrin@apple.com>
+
+        Reviewed by Simon Fraser
+
+        https://bugs.webkit.org/show_bug.cgi?id=23689
+
+        Added 3D functions to WebKitCSSMatrix. This depends on the 3D functions
+        added to TransformationMatrix in https://bugs.webkit.org/show_bug.cgi?id=6868
+
+        Test: transforms/3d/cssmatrix-3d-interface.xhtml
+
+        * css/WebKitCSSMatrix.cpp:
+        * css/WebKitCSSMatrix.h:
+        * css/WebKitCSSMatrix.idl:
+
 2009-02-09  Mark Rowe  <mrowe@apple.com>
 
         Reviewed by Darin Adler.
index 134f412..574a01a 100644 (file)
@@ -24,6 +24,7 @@
  */
 
 #include "config.h"
+#include "WebKitCSSMatrix.h"
 
 #include "CSSParser.h"
 #include "CSSStyleSelector.h"
@@ -31,7 +32,7 @@
 #include "CSSPropertyNames.h"
 #include "ExceptionCode.h"
 #include "RenderStyle.h"
-#include "WebKitCSSMatrix.h"
+#include <wtf/MathExtras.h>
 
 namespace WebCore {
 
@@ -93,14 +94,17 @@ void WebKitCSSMatrix::setMatrixValue(const String& string, ExceptionCode& ec)
 }
 
 // This is a multRight (this = this * secondMatrix)
-PassRefPtr<WebKitCSSMatrix> WebKitCSSMatrix::multiply(WebKitCSSMatrix* secondMatrix)
+PassRefPtr<WebKitCSSMatrix> WebKitCSSMatrix::multiply(WebKitCSSMatrix* secondMatrix) const
 {
+    if (!secondMatrix)
+        return 0;
+
     TransformationMatrix tmp(m_matrix);
     tmp.multiply(secondMatrix->m_matrix);
     return WebKitCSSMatrix::create(tmp);
 }
 
-PassRefPtr<WebKitCSSMatrix> WebKitCSSMatrix::inverse(ExceptionCode& ec)
+PassRefPtr<WebKitCSSMatrix> WebKitCSSMatrix::inverse(ExceptionCode& ec) const
 {
     if (!m_matrix.isInvertible()) {
         ec = NOT_SUPPORTED_ERR;
@@ -110,35 +114,73 @@ PassRefPtr<WebKitCSSMatrix> WebKitCSSMatrix::inverse(ExceptionCode& ec)
     return WebKitCSSMatrix::create(m_matrix.inverse());
 }
 
-PassRefPtr<WebKitCSSMatrix> WebKitCSSMatrix::translate(float x, float y)
+PassRefPtr<WebKitCSSMatrix> WebKitCSSMatrix::translate(double x, double y, double z) const
 {
     if (isnan(x))
-        x = 0; 
+        x = 0;
     if (isnan(y))
-        y = 0; 
-    return WebKitCSSMatrix::create(m_matrix.translate(x, y));
+        y = 0;
+    if (isnan(z))
+        z = 0;
+    return WebKitCSSMatrix::create(TransformationMatrix(m_matrix).translate3d(x, y, z));
 }
 
-PassRefPtr<WebKitCSSMatrix> WebKitCSSMatrix::scale(float scaleX, float scaleY)
+PassRefPtr<WebKitCSSMatrix> WebKitCSSMatrix::scale(double scaleX, double scaleY, double scaleZ) const
 {
     if (isnan(scaleX))
-        scaleX = 1; 
+        scaleX = 1;
     if (isnan(scaleY))
-        scaleY = scaleX; 
-    return WebKitCSSMatrix::create(m_matrix.scaleNonUniform(scaleX,scaleY));
+        scaleY = scaleX;
+    if (isnan(scaleZ))
+        scaleZ = 1;
+    return WebKitCSSMatrix::create(TransformationMatrix(m_matrix).scale3d(scaleX, scaleY, scaleZ));
 }
 
-PassRefPtr<WebKitCSSMatrix> WebKitCSSMatrix::rotate(float rot)
+PassRefPtr<WebKitCSSMatrix> WebKitCSSMatrix::rotate(double rotX, double rotY, double rotZ) const
 {
-    if (isnan(rot))
-        rot = 0;
-    return WebKitCSSMatrix::create(m_matrix.rotate(rot));
+    if (isnan(rotX))
+        rotX = 0;
+        
+    if (isnan(rotY) && isnan(rotZ)) {
+        rotZ = rotX;
+        rotX = 0;
+        rotY = 0;
+    }
+
+    if (isnan(rotY))
+        rotY = 0;
+    if (isnan(rotZ))
+        rotZ = 0;
+    return WebKitCSSMatrix::create(TransformationMatrix(m_matrix).rotate3d(rotX, rotY, rotZ));
 }
 
-String WebKitCSSMatrix::toString()
+PassRefPtr<WebKitCSSMatrix> WebKitCSSMatrix::rotateAxisAngle(double x, double y, double z, double angle) const
+{
+    if (isnan(x))
+        x = 0;
+    if (isnan(y))
+        y = 0;
+    if (isnan(z))
+        z = 0;
+    if (isnan(angle))
+        angle = 0;
+    if (x == 0 && y == 0 && z == 0)
+        z = 1;
+    return WebKitCSSMatrix::create(TransformationMatrix(m_matrix).rotate3d(x, y, z, angle));
+}
+
+
+String WebKitCSSMatrix::toString() const
 {
-    return String::format("matrix(%f, %f, %f, %f, %f, %f)",
-                            m_matrix.a(), m_matrix.b(), m_matrix.c(), m_matrix.d(), m_matrix.e(), m_matrix.f());
+    // FIXME - Need to ensure valid CSS floating point values (https://bugs.webkit.org/show_bug.cgi?id=20674)
+    if (m_matrix.isAffine())
+        return String::format("matrix(%f, %f, %f, %f, %f, %f)",
+                                m_matrix.a(), m_matrix.b(), m_matrix.c(), m_matrix.d(), m_matrix.e(), m_matrix.f());
+    return String::format("matrix3d(%f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f)",
+                            m_matrix.m11(), m_matrix.m12(), m_matrix.m13(), m_matrix.m14(),
+                            m_matrix.m21(), m_matrix.m22(), m_matrix.m23(), m_matrix.m24(),
+                            m_matrix.m31(), m_matrix.m32(), m_matrix.m33(), m_matrix.m34(),
+                            m_matrix.m41(), m_matrix.m42(), m_matrix.m43(), m_matrix.m44());
 }
 
 } // namespace WebCore
index 1c660bf..67ba113 100644 (file)
@@ -26,8 +26,9 @@
 #ifndef WebKitCSSMatrix_h
 #define WebKitCSSMatrix_h
 
-#include "StyleBase.h"
+#include "ExceptionCode.h"
 #include "PlatformString.h"
+#include "StyleBase.h"
 #include "TransformationMatrix.h"
 #include <wtf/PassRefPtr.h>
 #include <wtf/RefPtr.h>
@@ -55,34 +56,94 @@ public:
     
     virtual ~WebKitCSSMatrix();
 
-    float a() const { return static_cast<float>(m_matrix.a()); }
-    float b() const { return static_cast<float>(m_matrix.b()); }
-    float c() const { return static_cast<float>(m_matrix.c()); }
-    float d() const { return static_cast<float>(m_matrix.d()); }
-    float e() const { return static_cast<float>(m_matrix.e()); }
-    float f() const { return static_cast<float>(m_matrix.f()); }
+    double a() const { return m_matrix.a(); }
+    double b() const { return m_matrix.b(); }
+    double c() const { return m_matrix.c(); }
+    double d() const { return m_matrix.d(); }
+    double e() const { return m_matrix.e(); }
+    double f() const { return m_matrix.f(); }
     
-    void setA(float f) { m_matrix.setA(f); }
-    void setB(float f) { m_matrix.setB(f); }
-    void setC(float f) { m_matrix.setC(f); }
-    void setD(float f) { m_matrix.setD(f); }
-    void setE(float f) { m_matrix.setE(f); }
-    void setF(float f) { m_matrix.setF(f); }
+    void setA(double f) { m_matrix.setA(f); }
+    void setB(double f) { m_matrix.setB(f); }
+    void setC(double f) { m_matrix.setC(f); }
+    void setD(double f) { m_matrix.setD(f); }
+    void setE(double f) { m_matrix.setE(f); }
+    void setF(double f) { m_matrix.setF(f); }
+    double m11() const { return m_matrix.m11(); }
+    double m12() const { return m_matrix.m12(); }
+    double m13() const { return m_matrix.m13(); }
+    double m14() const { return m_matrix.m14(); }
+    double m21() const { return m_matrix.m21(); }
+    double m22() const { return m_matrix.m22(); }
+    double m23() const { return m_matrix.m23(); }
+    double m24() const { return m_matrix.m24(); }
+    double m31() const { return m_matrix.m31(); }
+    double m32() const { return m_matrix.m32(); }
+    double m33() const { return m_matrix.m33(); }
+    double m34() const { return m_matrix.m34(); }
+    double m41() const { return m_matrix.m41(); }
+    double m42() const { return m_matrix.m42(); }
+    double m43() const { return m_matrix.m43(); }
+    double m44() const { return m_matrix.m44(); }
+    
+    void setM11(double f) { m_matrix.setM11(f); }
+    void setM12(double f) { m_matrix.setM12(f); }
+    void setM13(double f) { m_matrix.setM13(f); }
+    void setM14(double f) { m_matrix.setM14(f); }
+    void setM21(double f) { m_matrix.setM21(f); }
+    void setM22(double f) { m_matrix.setM22(f); }
+    void setM23(double f) { m_matrix.setM23(f); }
+    void setM24(double f) { m_matrix.setM24(f); }
+    void setM31(double f) { m_matrix.setM31(f); }
+    void setM32(double f) { m_matrix.setM32(f); }
+    void setM33(double f) { m_matrix.setM33(f); }
+    void setM34(double f) { m_matrix.setM34(f); }
+    void setM41(double f) { m_matrix.setM41(f); }
+    void setM42(double f) { m_matrix.setM42(f); }
+    void setM43(double f) { m_matrix.setM43(f); }
+    void setM44(double f) { m_matrix.setM44(f); }
  
     void setMatrixValue(const String& string, ExceptionCode&);
     
-    // this = this * secondMatrix
-    PassRefPtr<WebKitCSSMatrix> multiply(WebKitCSSMatrix* secondMatrix);
+    // The following math function return a new matrix with the 
+    // specified operation applied. The this value is not modified.
+    
+    // Multiply this matrix by secondMatrix, on the right (result = this * secondMatrix)
+    PassRefPtr<WebKitCSSMatrix> multiply(WebKitCSSMatrix* secondMatrix) const;
+    
+    // Return the inverse of this matrix. Throw an exception if the matrix is not invertible
+    PassRefPtr<WebKitCSSMatrix> inverse(ExceptionCode&) const;
+    
+    // Return this matrix translated by the passed values.
+    // Passing a NaN will use a value of 0. This allows the 3D form to used for 2D operations
+    // Operation is performed as though the this matrix is multiplied by a matrix with
+    // the translation values on the left (result = translation(x,y,z) * this)
+    PassRefPtr<WebKitCSSMatrix> translate(double x, double y, double z) const;
+    
+    // Returns this matrix scaled by the passed values.
+    // Passing scaleX or scaleZ as NaN uses a value of 1, but passing scaleY of NaN 
+    // makes it the same as scaleX. This allows the 3D form to used for 2D operations
+    // Operation is performed as though the this matrix is multiplied by a matrix with
+    // the scale values on the left (result = scale(x,y,z) * this)
+    PassRefPtr<WebKitCSSMatrix> scale(double scaleX, double scaleY, double scaleZ) const;
+
+    // Returns this matrix rotated by the passed values.
+    // If rotY and rotZ are NaN, rotate about Z (rotX=0, rotateY=0, rotateZ=rotX).
+    // Otherwise use a rotation value of 0 for any passed NaN.    
+    // Operation is performed as though the this matrix is multiplied by a matrix with
+    // the rotation values on the left (result = rotation(x,y,z) * this)
+    PassRefPtr<WebKitCSSMatrix> rotate(double rotX, double rotY, double rotZ) const;
     
-    // FIXME: we really should have an exception here, for when matrix is not invertible
-    PassRefPtr<WebKitCSSMatrix> inverse(ExceptionCode&);
-    PassRefPtr<WebKitCSSMatrix> translate(float x, float y);
-    PassRefPtr<WebKitCSSMatrix> scale(float scaleX, float scaleY);
-    PassRefPtr<WebKitCSSMatrix> rotate(float rot);
+    // Returns this matrix rotated about the passed axis by the passed angle.
+    // Passing a NaN will use a value of 0. If the axis is (0,0,0) use a value
+    // Operation is performed as though the this matrix is multiplied by a matrix with
+    // the rotation values on the left (result = rotation(x,y,z,angle) * this)
+    PassRefPtr<WebKitCSSMatrix> rotateAxisAngle(double x, double y, double z, double angle) const;
     
-    const TransformationMatrix& transform() { return m_matrix; }
+    const TransformationMatrix& transform() const { return m_matrix; }
     
-    String toString();
+    String toString() const;
     
 protected:
     WebKitCSSMatrix();
index b1d5946..6b22da1 100644 (file)
@@ -28,19 +28,57 @@ module css {
     // Introduced in DOM Level ?:
     interface WebKitCSSMatrix {
 
-        attribute float a;
-        attribute float b;
-        attribute float c;
-        attribute float d;
-        attribute float e;
-        attribute float f;
+        // These attributes are simple aliases for certain elements of the 4x4 matrix
+        attribute double a; // alias for m11
+        attribute double b; // alias for m12
+        attribute double c; // alias for m21
+        attribute double d; // alias for m22
+        attribute double e; // alias for m41
+        attribute double f; // alias for m42
 
-        void            setMatrixValue(in DOMString string) raises (DOMException);
-        WebKitCSSMatrix multiply(in WebKitCSSMatrix secondMatrix);
-        WebKitCSSMatrix inverse() raises (DOMException);
-        WebKitCSSMatrix translate(in float x, in float y);
-        WebKitCSSMatrix scale(in float scaleX, in float scaleY);
-        WebKitCSSMatrix rotate(in float rot);
+        attribute double m11;
+        attribute double m12;
+        attribute double m13;
+        attribute double m14;
+        attribute double m21;
+        attribute double m22;
+        attribute double m23;
+        attribute double m24;
+        attribute double m31;
+        attribute double m32;
+        attribute double m33;
+        attribute double m34;
+        attribute double m41;
+        attribute double m42;
+        attribute double m43;
+        attribute double m44;
+
+        void setMatrixValue(in DOMString string) raises (DOMException);
+        
+        // Multiply this matrix by secondMatrix, on the right (result = this * secondMatrix)
+        [Immutable] WebKitCSSMatrix multiply(in WebKitCSSMatrix secondMatrix);
+        
+        // Return the inverse of this matrix. Throw an exception if the matrix is not invertible
+        [Immutable] WebKitCSSMatrix inverse() raises (DOMException);
+        
+        // Return this matrix translated by the passed values.
+        // Passing a NaN will use a value of 0. This allows the 3D form to used for 2D operations    
+        [Immutable] WebKitCSSMatrix translate(in double x, in double y, in double z);
+        
+        // Returns this matrix scaled by the passed values.
+        // Passing scaleX or scaleZ as NaN uses a value of 1, but passing scaleY of NaN 
+        // makes it the same as scaleX. This allows the 3D form to used for 2D operations
+        [Immutable] WebKitCSSMatrix scale(in double scaleX, in double scaleY, in double scaleZ);
+        
+        // Returns this matrix rotated by the passed values.
+        // If rotY and rotZ are NaN, rotate about Z (rotX=0, rotateY=0, rotateZ=rotX).
+        // Otherwise use a rotation value of 0 for any passed NaN.    
+        [Immutable] WebKitCSSMatrix rotate(in double rotX, in double rotY, in double rotZ);
+        
+        // Returns this matrix rotated about the passed axis by the passed angle.
+        // Passing a NaN will use a value of 0. If the axis is (0,0,0) use a value
+        // of (0,0,1).
+        [Immutable] WebKitCSSMatrix rotateAxisAngle(in double x, in double y, in double z, in double angle);
         
         [DontEnum] DOMString toString();
     };