/**
* Matrix is a class that allows for the manipulation of a transform matrix.
* This class is a work in progress.
*
* @class Matrix
* @constructor
* @module matrix
*/
var Matrix = function(config) {
this.init(config);
};
Matrix.prototype = {
/**
* Used as value for the _rounding method.
*
* @property _rounder
* @private
*/
_rounder: 100000,
/**
* Updates the matrix.
*
* @method multiple
* @param {Number} a
* @param {Number} b
* @param {Number} c
* @param {Number} d
* @param {Number} dx
* @param {Number} dy
*/
multiply: function(a, b, c, d, dx, dy) {
var matrix = this,
matrix_a = matrix.a * a + matrix.c * b,
matrix_b = matrix.b * a + matrix.d * b,
matrix_c = matrix.a * c + matrix.c * d,
matrix_d = matrix.b * c + matrix.d * d,
matrix_dx = matrix.a * dx + matrix.c * dy + matrix.dx,
matrix_dy = matrix.b * dx + matrix.d * dy + matrix.dy;
matrix.a = this._round(matrix_a);
matrix.b = this._round(matrix_b);
matrix.c = this._round(matrix_c);
matrix.d = this._round(matrix_d);
matrix.dx = this._round(matrix_dx);
matrix.dy = this._round(matrix_dy);
return this;
},
/**
* Parses a string and updates the matrix.
*
* @method applyCSSText
* @param {String} val A css transform string
*/
applyCSSText: function(val) {
var re = /\s*([a-z]*)\(([\w,\.,\-,\s]*)\)/gi,
args,
m;
val = val.replace(/matrix/g, "multiply");
while ((m = re.exec(val))) {
if (typeof this[m[1]] === 'function') {
args = m[2].split(',');
this[m[1]].apply(this, args);
}
}
},
/**
* Parses a string and returns an array of transform arrays.
*
* @method getTransformArray
* @param {String} val A css transform string
* @return Array
*/
getTransformArray: function(val) {
var re = /\s*([a-z]*)\(([\w,\.,\-,\s]*)\)/gi,
transforms = [],
args,
m;
val = val.replace(/matrix/g, "multiply");
while ((m = re.exec(val))) {
if (typeof this[m[1]] === 'function') {
args = m[2].split(',');
args.unshift(m[1]);
transforms.push(args);
}
}
return transforms;
},
/**
* Default values for the matrix
*
* @property _defaults
* @private
*/
_defaults: {
a: 1,
b: 0,
c: 0,
d: 1,
dx: 0,
dy: 0
},
/**
* Rounds values
*
* @method _round
* @private
*/
_round: function(val) {
val = Math.round(val * this._rounder) / this._rounder;
return val;
},
/**
* Initializes a matrix.
*
* @method init
* @param {Object} config Specified key value pairs for matrix properties. If a property is not explicitly defined in the config argument,
* the default value will be used.
*/
init: function(config) {
var defaults = this._defaults,
prop;
config = config || {};
for (prop in defaults) {
if(defaults.hasOwnProperty(prop))
{
this[prop] = (prop in config) ? config[prop] : defaults[prop];
}
}
this._config = config;
},
/**
* Applies a scale transform
*
* @method scale
* @param {Number} val
*/
scale: function(x, y) {
this.multiply(x, 0, 0, y, 0, 0);
return this;
},
/**
* Applies a skew transformation.
*
* @method skew
* @param {Number} x The value to skew on the x-axis.
* @param {Number} y The value to skew on the y-axis.
*/
skew: function(x, y) {
x = x || 0;
y = y || 0;
if (x !== undefined) { // null or undef
x = Math.tan(this.angle2rad(x));
}
if (y !== undefined) { // null or undef
y = Math.tan(this.angle2rad(y));
}
this.multiply(1, y, x, 1, 0, 0);
return this;
},
/**
* Applies a skew to the x-coordinate
*
* @method skewX
* @param {Number} x x-coordinate
*/
skewX: function(x) {
this.skew(x);
return this;
},
/**
* Applies a skew to the y-coordinate
*
* @method skewY
* @param {Number} y y-coordinate
*/
skewY: function(y) {
this.skew(null, y);
return this;
},
/**
* Returns a string of text that can be used to populate a the css transform property of an element.
*
* @method toCSSText
* @return String
*/
toCSSText: function() {
var matrix = this,
text = 'matrix(' +
matrix.a + ',' +
matrix.b + ',' +
matrix.c + ',' +
matrix.d + ',' +
matrix.dx + ',' +
matrix.dy + ')';
return text;
},
/**
* Returns a string that can be used to populate the css filter property of an element.
*
* @method toFilterText
* @return String
*/
toFilterText: function() {
var matrix = this,
text = 'progid:DXImageTransform.Microsoft.Matrix(';
text += 'M11=' + matrix.a + ',' +
'M21=' + matrix.b + ',' +
'M12=' + matrix.c + ',' +
'M22=' + matrix.d + ',' +
'sizingMethod="auto expand")';
text += '';
return text;
},
/**
* Converts a radian value to a degree.
*
* @method rad2deg
* @param {Number} rad Radian value to be converted.
* @return Number
*/
rad2deg: function(rad) {
var deg = rad * (180 / Math.PI);
return deg;
},
/**
* Converts a degree value to a radian.
*
* @method deg2rad
* @param {Number} deg Degree value to be converted to radian.
* @return Number
*/
deg2rad: function(deg) {
var rad = deg * (Math.PI / 180);
return rad;
},
angle2rad: function(val) {
if (typeof val === 'string' && val.indexOf('rad') > -1) {
val = parseFloat(val);
} else { // default to deg
val = this.deg2rad(parseFloat(val));
}
return val;
},
/**
* Applies a rotate transform.
*
* @method rotate
* @param {Number} deg The degree of the rotation.
*/
rotate: function(deg, x, y) {
var rad = this.angle2rad(deg),
sin = Math.sin(rad),
cos = Math.cos(rad);
this.multiply(cos, sin, 0 - sin, cos, 0, 0);
return this;
},
/**
* Applies translate transformation.
*
* @method translate
* @param {Number} x The value to transate on the x-axis.
* @param {Number} y The value to translate on the y-axis.
*/
translate: function(x, y) {
x = parseFloat(x) || 0;
y = parseFloat(y) || 0;
this.multiply(1, 0, 0, 1, x, y);
return this;
},
/**
* Applies a translate to the x-coordinate
*
* @method translateX
* @param {Number} x x-coordinate
*/
translateX: function(x) {
this.translate(x);
return this;
},
/**
* Applies a translate to the y-coordinate
*
* @method translateY
* @param {Number} y y-coordinate
*/
translateY: function(y) {
this.translate(null, y);
return this;
},
/**
* Returns an identity matrix.
*
* @method identity
* @return Object
*/
identity: function() {
var config = this._config,
defaults = this._defaults,
prop;
for (prop in config) {
if (prop in defaults) {
this[prop] = defaults[prop];
}
}
return this;
},
/**
* Returns a 3x3 Matrix array
*
* / \
* | matrix[0][0] matrix[1][0] matrix[2][0] |
* | matrix[0][1] matrix[1][1] matrix[2][1] |
* | matrix[0][2] matrix[1][2] matrix[2][2] |
* \ /
*
* @method getMatrixArray
* @return Array
*/
getMatrixArray: function()
{
var matrix = this,
matrixArray = [
[matrix.a, matrix.c, matrix.dx],
[matrix.b, matrix.d, matrix.dy],
[0, 0, 1]
];
return matrixArray;
},
/**
* Returns the left, top, right and bottom coordinates for a transformed
* item.
*
* @method getContentRect
* @param {Number} width The width of the item.
* @param {Number} height The height of the item.
* @param {Number} x The x-coordinate of the item.
* @param {Number} y The y-coordinate of the item.
* @return Object
*/
getContentRect: function(width, height, x, y)
{
var left = !isNaN(x) ? x : 0,
top = !isNaN(y) ? y : 0,
right = left + width,
bottom = top + height,
matrix = this,
a = matrix.a,
b = matrix.b,
c = matrix.c,
d = matrix.d,
dx = matrix.dx,
dy = matrix.dy,
x1 = (a * left + c * top + dx),
y1 = (b * left + d * top + dy),
//[x2, y2]
x2 = (a * right + c * top + dx),
y2 = (b * right + d * top + dy),
//[x3, y3]
x3 = (a * left + c * bottom + dx),
y3 = (b * left + d * bottom + dy),
//[x4, y4]
x4 = (a * right + c * bottom + dx),
y4 = (b * right + d * bottom + dy);
return {
left: Math.min(x3, Math.min(x1, Math.min(x2, x4))),
right: Math.max(x3, Math.max(x1, Math.max(x2, x4))),
top: Math.min(y2, Math.min(y4, Math.min(y3, y1))),
bottom: Math.max(y2, Math.max(y4, Math.max(y3, y1)))
};
},
/**
* Returns the determinant of the matrix.
*
* @method getDeterminant
* @return Number
*/
getDeterminant: function()
{
return Y.MatrixUtil.getDeterminant(this.getMatrixArray());
},
/**
* Returns the inverse (in array form) of the matrix.
*
* @method inverse
* @return Array
*/
inverse: function()
{
return Y.MatrixUtil.inverse(this.getMatrixArray());
},
/**
* Returns the transpose of the matrix
*
* @method transpose
* @return Array
*/
transpose: function()
{
return Y.MatrixUtil.transpose(this.getMatrixArray());
},
/**
* Returns an array of transform commands that represent the matrix.
*
* @method decompose
* @return Array
*/
decompose: function()
{
return Y.MatrixUtil.decompose(this.getMatrixArray());
}
};
Y.Matrix = Matrix;
