diff -r dc7c549001d5 -r 85266cc22c7f javauis/eswt_qt/s60utils/java/src/com/nokia/mj/impl/uitestutils/Matrix.java
--- a/javauis/eswt_qt/s60utils/java/src/com/nokia/mj/impl/uitestutils/Matrix.java Thu May 27 12:49:31 2010 +0300
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,274 +0,0 @@
-/*
-* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
-* All rights reserved.
-* This component and the accompanying materials are made available
-* under the terms of "Eclipse Public License v1.0"
-* which accompanies this distribution, and is available
-* at the URL "http://www.eclipse.org/legal/epl-v10.html".
-*
-* Initial Contributors:
-* Nokia Corporation - initial contribution.
-*
-* Contributors:
-*
-* Description:
-*
-*/
-package com.nokia.mj.impl.uitestutils;
-
-/**
- * Matrix calculation implementation.
- *
- */
-public class Matrix {
-
- static final int ARRAY_SIZE = 6;
- // Array index
- static private final int M00 = 0;
- static private final int M10 = 1;
- static private final int M01 = 2;
- static private final int M11 = 3;
- static private final int M02 = 4;
- static private final int M12 = 5;
-
- private float iComponents[];
-
- /**
- * Construct a matrix with the following components:
- *
- * [1 0 0]
- * [0 1 0]
- *
- */
- public Matrix() {
- iComponents = new float[ARRAY_SIZE];
- identity();
- }
-
- /**
- * Construct a matrix with the following components:
- *
- * [aM00 aM01 aM02]
- * [aM10 aM11 aM12]
- *
- * @param aM00 the x scaling component
- * @param aM10 the y shearing component
- * @param aM01 the x shearing component
- * @param aM11 the y scaling component
- * @param aM02 the x translation component
- * @param aM12 the y translation component
- */
- public Matrix(float aM00, float aM10, float aM01,
- float aM11, float aM02, float aM12) {
- iComponents = new float[ARRAY_SIZE];
- iComponents[M00] = aM00; iComponents[M01] = aM01; iComponents[M02] = aM02;
- iComponents[M10] = aM10; iComponents[M11] = aM11; iComponents[M12] = aM12;
- }
-
- /**
- * Constructor
- * Create a new matrix by coping the given one.
- * @param aMatrix the matrix to copy
- */
- public Matrix(Matrix aMatrix) {
- iComponents = new float[aMatrix.iComponents.length];
- for(int index = 0; index < iComponents.length; index++) {
- iComponents[index] = aMatrix.iComponents[index];
- }
- }
-
- /**
- *
- */
- public float getComponent(int index) {
- return iComponents[index];
- }
-
- /**
- * Set matrix components:
- *
- * [1 0 0]
- * [0 1 0]
- *
- *
- */
- public void identity()
- {
- iComponents[M00] = 1; iComponents[M01] = 0; iComponents[M02] = 0;
- iComponents[M10] = 0; iComponents[M11] = 1; iComponents[M12] = 0;
- }
-
- /**
- * Return transformed Point instance
- *
- * The transformation can be represented using matrix math on a 3x3 array.
- * Given (x,y), the transformation (x',y') can be found by:
- * [ x'] [ m00 m01 m02 ] [ x ] [ m00*x + m01*y + m02 ]
- * [ y'] = [ m10 m11 m12 ] [ y ] = [ m10*x + m11*y + m12 ]
- * [ 1 ] [ 0 0 1 ] [ 1 ] [ 1 ]
- *
- * The bottom row of the matrix is constant, so a transform can be uniquely
- * represented by "[[m00, m01, m02], [m10, m11, m12]]".
- * @param p the source point
- * @return new point instance
- */
- public Point transform(final Point p)
- {
- return new Point(
- iComponents[M00] * p.x + iComponents[M01] * p.y + iComponents[M02],
- iComponents[M10] * p.x + iComponents[M11] * p.y + iComponents[M12]);
- }
-
- /**
- * Return the matrix of components used in this transform. The resulting
- * values are:
- *
- * [array[0] array[2] array[4]]
- * [array[1] array[3] array[5]]
- *
- * @return array that contains the matrix components.
- */
- float[] getComponents() {
- return iComponents;
- }
-
-
- /**
- * Return the determinant of this transform matrix. If the determinant is
- * non-zero, the transform is invertible.
- * The determinant is calculated as:
- *
- * [m00 m01 m02]
- * [m10 m11 m12] = m00 * m11 - m01 * m10
- * [ 0 0 1 ]
- *
- * @return the determinant
- */
- public float determinant() {
- return ((iComponents[M00] * iComponents[M11]) -
- (iComponents[M01] * iComponents[M10]));
- }
-
- /**
- * The inverse is calculated as:
- *
- * [m00 m01 m02]
- * M= [m10 m11 m12]
- * [ 0 0 1 ]
- *
- * 1 [ m11/det -m01/det (m01*m12-m02*m11)/det]
- * inverse(M)= --- x adjoint(M) = [-m10/det m00/det (m10*m02-m00*m12)/det]
- * det [ 0 0 1 ]
- *
- */
- public Matrix inverse() {
- // The inversion is useful for undoing transformations.
- float det = determinant();
- if (det == 0)
- {
- throw new RuntimeException("Invalid determinant");
- }
- return new Matrix(
- iComponents[M11] / det, // iMtx[M00]
- (-iComponents[M10]) / det, // iMtx[M10]
- (-iComponents[M01]) / det, // iMtx[M01]
- iComponents[M00] / det, // iMtx[M11]
- ((iComponents[M01] * iComponents[M12]) - (iComponents[M02] * iComponents[M11])) / det,
- ((iComponents[M10] * iComponents[M02]) - (iComponents[M00] * iComponents[M12])) / det);
- }
-
- /**
- * The multiply is calculated as:
- *
- * [a00 a01 a02] [b00 b01 b02]
- * this=[a10 a11 a12] B=[b10 b11 b12]
- * [ 0 0 1 ] [ 0 0 1 ]
- *
- * [(a00*b00+a01*b10) (a00*b01+a01*b11) (a00*b02+a01*b12+a02)]
- * [this] = [this]x[B] = [(a10*b00+a11*b10) (a10*b01+a11*b11) (a10*b02+a11*b12+a12)]
- * [ 0 0 1 ]
- *
- */
- public Matrix multiply(Matrix b) {
- if(b == null)
- {
- throw new NullPointerException();
- }
- float a00 = iComponents[M00]; // a
- float a10 = iComponents[M10]; // b
- float a01 = iComponents[M01]; // c
- float a11 = iComponents[M11]; // d
- float a02 = iComponents[M02]; // e
- float a12 = iComponents[M12]; // f
- iComponents[M00] = (a00 * b.iComponents[M00]) + (a01 * b.iComponents[M10]); // a
- iComponents[M10] = (a10 * b.iComponents[M00]) + (a11 * b.iComponents[M10]); // b
- iComponents[M01] = (a00 * b.iComponents[M01]) + (a01 * b.iComponents[M11]); // c
- iComponents[M11] = (a10 * b.iComponents[M01]) + (a11 * b.iComponents[M11]); // d
- iComponents[M02] = (a00 * b.iComponents[M02]) + (a01 * b.iComponents[M12]) + a02; // e
- iComponents[M12] = (a10 * b.iComponents[M02]) + (a11 * b.iComponents[M12]) + a12; // f
- return this;
- }
-
- /**
- * The rotation is calculated as:
- *
- * [ cos(angle) -sin(angle) 0 ]
- * [this] x [ sin(angle) cos(angle) 0 ]
- * [ 0 0 1 ]
- *
- */
- public Matrix rotate(float angle) {
- if (angle % 360 == 0) {
- return this;
- }
- // Must convert degrees to radians since java.lang.Math expects radians
- angle = angle * (float)Math.PI / 180.0f;
- float c = (float)Math.cos(angle);
- float s = (float)Math.sin(angle);
- float m00 = iComponents[M00];
- float m10 = iComponents[M10];
- float m01 = iComponents[M01];
- float m11 = iComponents[M11];
- iComponents[M00] = m00 * c + m01 * s;
- iComponents[M10] = m10 * c + m11 * s;
- iComponents[M01] = m01 * c - m00 * s;
- iComponents[M11] = m11 * c - m10 * s;
- return this;
- }
-
- /**
- * The multiply is calculated as:
- *
- * [m00 m01 m02] [scaleFactor 0 0]
- * this=[m10 m11 m12] B=[ 0 scaleFactor 0]
- * [ 0 0 1 ] [ 0 0 1]
- *
- * [(a00*scaleFactor) (a01*scaleFactor) a02]
- * [this] = [this]x[B] = [(a10*scaleFactor) (a11*scaleFactor) a12]
- * [ 0 0 1 ]
- *
- * @see org.w3c.dom.svg.SVGMatrix#mScale()
- */
- public Matrix scale(float scaleFactor) {
- if(scaleFactor == 1) {
- return this;
- }
- iComponents[M00] *= scaleFactor;
- iComponents[M01] *= scaleFactor;
- iComponents[M10] *= scaleFactor;
- iComponents[M11] *= scaleFactor;
- return this;
- }
-
- /**
- *
- */
- public Matrix translate(float x, float y) {
- if(x == 0 && y == 0) {
- return this;
- }
- iComponents[M02] += (iComponents[M00] * x) + (iComponents[M01] * y);
- iComponents[M12] += (iComponents[M10] * x) + (iComponents[M11] * y);
- return this;
- }
-}