layout/style/nsStyleTransformMatrix.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* ***** BEGIN LICENSE BLOCK *****
   3  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   4  *
   5  * The contents of this file are subject to the Mozilla Public License Version
   6  * 1.1 (the "License"); you may not use this file except in compliance with
   7  * the License. You may obtain a copy of the License at
   8  * http://www.mozilla.org/MPL/
   9  *
  10  * Software distributed under the License is distributed on an "AS IS" basis,
  11  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  12  * for the specific language governing rights and limitations under the
  13  * License.
  14  *
  15  * The Original Code is mozilla.org code.
  16  *
  17  * The Initial Developer of the Original Code is
  18  *   Mozilla Corporation
  19  *
  20  * Contributor(s):
  21  *   Keith Schwarz <kschwarz@mozilla.com> (original author)
  22  *
  23  * Alternatively, the contents of this file may be used under the terms of
  24  * either of the GNU General Public License Version 2 or later (the "GPL"),
  25  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  26  * in which case the provisions of the GPL or the LGPL are applicable instead
  27  * of those above. If you wish to allow use of your version of this file only
  28  * under the terms of either the GPL or the LGPL, and not to allow others to
  29  * use your version of this file under the terms of the MPL, indicate your
  30  * decision by deleting the provisions above and replace them with the notice
  31  * and other provisions required by the GPL or the LGPL. If you do not delete
  32  * the provisions above, a recipient may use your version of this file under
  33  * the terms of any one of the MPL, the GPL or the LGPL.
  34  *
  35  * ***** END LICENSE BLOCK ***** */
  36
  37 /*
  38  * A class used for intermediate representations of the -moz-transform property.
  39  */
  40
  41 #include "nsStyleTransformMatrix.h"
  42 #include "nsAutoPtr.h"
  43 #include "nsCSSValue.h"
  44 #include "nsStyleContext.h"
  45 #include "nsPresContext.h"
  46 #include "nsRuleNode.h"
  47 #include "nsCSSKeywords.h"
  48 #include "nsMathUtils.h"
  49
  50 /* Note on floating point precision: The transform matrix is an array
  51  * of single precision 'float's, and so are most of the input values
  52  * we get from the style system, but intermediate calculations
  53  * involving angles need to be done in 'double'.
  54  */
  55
  56 /* Force small values to zero.  We do this to avoid having sin(360deg)
  57  * evaluate to a tiny but nonzero value.
  58  */
  59 static double FlushToZero(double aVal)
  60 {
  61   if (-FLT_EPSILON < aVal && aVal < FLT_EPSILON)
  62     return 0.0f;
  63   else
  64     return aVal;
  65 }
  66
  67 /* Computes tan(aTheta).  For values of aTheta such that tan(aTheta) is
  68  * undefined or very large, SafeTangent returns a manageably large value
  69  * of the correct sign.
  70  */
  71 static double SafeTangent(double aTheta)
  72 {
  73   const double kEpsilon = 0.0001;
  74
  75   /* tan(theta) = sin(theta)/cos(theta); problems arise when
  76    * cos(theta) is too close to zero.  Limit cos(theta) to the
  77    * range [-1, -epsilon] U [epsilon, 1].
  78    */
  79   double sinTheta = sin(aTheta);
  80   double cosTheta = cos(aTheta);
  81
  82   if (cosTheta >= 0 && cosTheta < kEpsilon)
  83     cosTheta = kEpsilon;
  84   else if (cosTheta < 0 && cosTheta >= -kEpsilon)
  85     cosTheta = -kEpsilon;
  86
  87   return FlushToZero(sinTheta / cosTheta);
  88 }
  89
  90 /* Constructor sets the data to the identity matrix. */
  91 nsStyleTransformMatrix::nsStyleTransformMatrix()
  92 {
  93   SetToIdentity();
  94 }
  95
  96 /* SetToIdentity just fills in the appropriate values. */
  97 void nsStyleTransformMatrix::SetToIdentity()
  98 {
  99     /* Set the main matrix to the identity. */
 100   mMain[0] = 1.0f;
 101   mMain[1] = 0.0f;
 102   mMain[2] = 0.0f;
 103   mMain[3] = 1.0f;
 104   mDelta[0] = 0;
 105   mDelta[1] = 0;
 106
 107   /* Both translation matrices are zero. */
 108   mX[0] = 0.0f;
 109   mX[1] = 0.0f;
 110   mY[0] = 0.0f;
 111   mY[1] = 0.0f;
 112 }
 113
 114 /* Adds the constant translation to the scale factor translation components. */
 115 nscoord nsStyleTransformMatrix::GetXTranslation(const nsRect& aBounds) const
 116 {
 117   return NSToCoordRound(aBounds.width * mX[0] + aBounds.height * mY[0]) +
 118     mDelta[0];
 119 }
 120 nscoord nsStyleTransformMatrix::GetYTranslation(const nsRect& aBounds) const
 121 {
 122   return NSToCoordRound(aBounds.width * mX[1] + aBounds.height * mY[1]) +
 123     mDelta[1];
 124 }
 125
 126 /* GetThebesMatrix converts the stored matrix in a few steps. */
 127 gfxMatrix nsStyleTransformMatrix::GetThebesMatrix(const nsRect& aBounds,
 128                                                   float aScale) const
 129 {
 130   /* Compute the graphics matrix.  We take the stored main elements, along with
 131    * the delta, and add in the matrices:
 132    *
 133    * | 0 0 dx1|
 134    * | 0 0 dx2| * width
 135    * | 0 0   0|
 136    *
 137    * | 0 0 dy1|
 138    * | 0 0 dy2| * height
 139    * | 0 0   0|
 140    */
 141   return gfxMatrix(mMain[0], mMain[1], mMain[2], mMain[3],
 142                    NSAppUnitsToFloatPixels(GetXTranslation(aBounds), aScale),
 143                    NSAppUnitsToFloatPixels(GetYTranslation(aBounds), aScale));
 144 }
 145
 146 /* Performs the matrix multiplication necessary to multiply the two matrices,
 147  * then hands back a reference to ourself.
 148  */
 149 nsStyleTransformMatrix&
 150 nsStyleTransformMatrix::operator *= (const nsStyleTransformMatrix &aOther)
 151 {
 152   /* We'll buffer all of our results into a temporary storage location
 153    * during this operation since we don't want to overwrite the values of
 154    * the old matrix with the values of the new.
 155    */
 156   float newMatrix[4];
 157   nscoord newDelta[2];
 158   float newX[2];
 159   float newY[2];
 160
 161   /*   [this]    [aOther]
 162    * |a1 c1 e1| |a0 c0 e0|   |a0a1 + b0c1    c0a1 + d0c1     e0a1 + f0c1 + e1|
 163    * |b1 d1 f1|x|b0 d0 f0| = |a0b1 + b0d1    c0b1 + d0d1     e0b1 + f0d1 + f1|
 164    * |0  0  1 | | 0  0  1|   |          0              0                    1|
 165    */
 166   newMatrix[0] = aOther.mMain[0] * mMain[0] + aOther.mMain[1] * mMain[2];
 167   newMatrix[1] = aOther.mMain[0] * mMain[1] + aOther.mMain[1] * mMain[3];
 168   newMatrix[2] = aOther.mMain[2] * mMain[0] + aOther.mMain[3] * mMain[2];
 169   newMatrix[3] = aOther.mMain[2] * mMain[1] + aOther.mMain[3] * mMain[3];
 170   newDelta[0] = NSToCoordRound(aOther.mDelta[0] * mMain[0] +
 171                                aOther.mDelta[1] * mMain[2]) + mDelta[0];
 172   newDelta[1] = NSToCoordRound(aOther.mDelta[0] * mMain[1] +
 173                                aOther.mDelta[1] * mMain[3]) + mDelta[1];
 174
 175   /* For consistent terminology, let u0, u1, v0, and v1 be the four transform
 176    * coordinates from our matrix, and let x0, x1, y0, and y1 be the four
 177    * transform coordinates from the other  matrix.  Then the new transform
 178    * coordinates are:
 179    *
 180    * u0' = a1u0 + c1u1 + x0
 181    * u1' = b1u0 + d1u1 + x1
 182    * v0' = a1v0 + c1v1 + y0
 183    * v1' = b1v0 + d1v1 + y1
 184    */
 185   newX[0] = mMain[0] * aOther.mX[0] + mMain[2] * aOther.mX[1] + mX[0];
 186   newX[1] = mMain[1] * aOther.mX[0] + mMain[3] * aOther.mX[1] + mX[1];
 187   newY[0] = mMain[0] * aOther.mY[0] + mMain[2] * aOther.mY[1] + mY[0];
 188   newY[1] = mMain[1] * aOther.mY[0] + mMain[3] * aOther.mY[1] + mY[1];
 189
 190   /* Now, write everything back in. */
 191   for (PRInt32 index = 0; index < 4; ++index)
 192     mMain[index] = newMatrix[index];
 193   for (PRInt32 index = 0; index < 2; ++index) {
 194     mDelta[index] = newDelta[index];
 195     mX[index] = newX[index];
 196     mY[index] = newY[index];
 197   }
 198
 199   /* As promised, return a reference to ourselves. */
 200   return *this;
 201 }
 202
 203 /* op* is implemented in terms of op*=. */
 204 const nsStyleTransformMatrix
 205 nsStyleTransformMatrix::operator *(const nsStyleTransformMatrix &aOther) const
 206 {
 207   return nsStyleTransformMatrix(*this) *= aOther;
 208 }
 209
 210 /* Helper function to fill in an nscoord with the specified nsCSSValue. */
 211 static void SetCoordToValue(const nsCSSValue &aValue,
 212                             nsStyleContext* aContext,
 213                             nsPresContext* aPresContext,
 214                             PRBool &aCanStoreInRuleTree, nscoord &aOut)
 215 {
 216   aOut = nsRuleNode::CalcLength(aValue, aContext, aPresContext,
 217                                 aCanStoreInRuleTree);
 218 }
 219
 220 /* Helper function to process a matrix entry. */
 221 static void ProcessMatrix(float aMain[4], nscoord aDelta[2],
 222                           float aX[2], float aY[2],
 223                           const nsCSSValue::Array* aData,
 224                           nsStyleContext* aContext,
 225                           nsPresContext* aPresContext,
 226                           PRBool& aCanStoreInRuleTree)
 227 {
 228   NS_PRECONDITION(aData->Count() == 7, "Invalid array!");
 229
 230   /* Take the first four elements out of the array as floats and store
 231    * them in aMain.
 232    */
 233   for (PRUint16 index = 1; index <= 4; ++index)
 234     aMain[index - 1] = aData->Item(index).GetFloatValue();
 235
 236   /* For the fifth element, if it's a percentage, store it in aX[0].
 237    * Otherwise, it's a length that needs to go in aDelta[0]
 238    */
 239   if (aData->Item(5).GetUnit() == eCSSUnit_Percent)
 240     aX[0] = aData->Item(5).GetPercentValue();
 241   else
 242     SetCoordToValue(aData->Item(5), aContext, aPresContext, aCanStoreInRuleTree,
 243                     aDelta[0]);
 244
 245   /* For the final element, if it's a percentage, store it in aY[1].
 246    * Otherwise, it's a length that needs to go in aDelta[1].
 247    */
 248   if (aData->Item(6).GetUnit() == eCSSUnit_Percent)
 249     aY[1] = aData->Item(6).GetPercentValue();
 250   else
 251     SetCoordToValue(aData->Item(6), aContext, aPresContext, aCanStoreInRuleTree,
 252                     aDelta[1]);
 253 }
 254
 255 /* Helper function to process a translatex function. */
 256 static void ProcessTranslateX(nscoord aDelta[2], float aX[2],
 257                               const nsCSSValue::Array* aData,
 258                               nsStyleContext* aContext,
 259                               nsPresContext* aPresContext,
 260                               PRBool& aCanStoreInRuleTree)
 261 {
 262   NS_PRECONDITION(aData->Count() == 2, "Invalid array!");
 263
 264   /* There are two cases.  If we have a number, we want our matrix to look
 265    * like this:
 266    *
 267    * |  1  0 dx|
 268    * |  0  1  0|
 269    * |  0  0  1|
 270    * So E = value
 271    *
 272    * Otherwise, we might have a percentage, so we want to set the dX component
 273    * to the percent.
 274    */
 275   if (aData->Item(1).GetUnit() != eCSSUnit_Percent)
 276     SetCoordToValue(aData->Item(1), aContext, aPresContext, aCanStoreInRuleTree,
 277                     aDelta[0]);
 278   else
 279     aX[0] = aData->Item(1).GetPercentValue();
 280 }
 281
 282 /* Helper function to process a translatey function. */
 283 static void ProcessTranslateY(nscoord aDelta[2], float aY[2],
 284                               const nsCSSValue::Array* aData,
 285                               nsStyleContext* aContext,
 286                               nsPresContext* aPresContext,
 287                               PRBool& aCanStoreInRuleTree)
 288 {
 289   NS_PRECONDITION(aData->Count() == 2, "Invalid array!");
 290
 291   /* There are two cases.  If we have a number, we want our matrix to look
 292    * like this:
 293    *
 294    * |  1  0  0|
 295    * |  0  1 dy|
 296    * |  0  0  1|
 297    * So E = value
 298    *
 299    * Otherwise, we might have a percentage, so we want to set the dY component
 300    * to the percent.
 301    */
 302   if (aData->Item(1).GetUnit() != eCSSUnit_Percent)
 303     SetCoordToValue(aData->Item(1), aContext, aPresContext, aCanStoreInRuleTree,
 304                     aDelta[1]);
 305   else
 306     aY[1] = aData->Item(1).GetPercentValue();
 307 }
 308
 309 /* Helper function to process a translate function. */
 310 static void ProcessTranslate(nscoord aDelta[2], float aX[2], float aY[2],
 311                              const nsCSSValue::Array* aData,
 312                              nsStyleContext* aContext,
 313                              nsPresContext* aPresContext,
 314                              PRBool& aCanStoreInRuleTree)
 315 {
 316   NS_PRECONDITION(aData->Count() == 2 || aData->Count() == 3, "Invalid array!");
 317
 318   /* There are several cases to consider.
 319    * First, we might have one value, or we might have two.  If we have
 320    * two, we need to consider both dX and dY components.
 321    * Next, the values might be lengths, or they might be percents.  If they're
 322    * percents, store them in the dX and dY components.  Otherwise, store them in
 323    * the main matrix.
 324    */
 325
 326   const nsCSSValue &dx = aData->Item(1);
 327   if (dx.GetUnit() == eCSSUnit_Percent)
 328     aX[0] = dx.GetPercentValue();
 329   else
 330     SetCoordToValue(dx, aContext, aPresContext, aCanStoreInRuleTree, aDelta[0]);
 331
 332   /* If we read in a Y component, set it appropriately */
 333   if (aData->Count() == 3) {
 334     const nsCSSValue &dy = aData->Item(2);
 335     if (dy.GetUnit() == eCSSUnit_Percent)
 336       aY[1] = dy.GetPercentValue();
 337     else
 338       SetCoordToValue(dy, aContext, aPresContext, aCanStoreInRuleTree,
 339                       aDelta[1]);
 340   }
 341 }
 342
 343 /* Helper function to set up a scale matrix. */
 344 static void ProcessScaleHelper(float aXScale, float aYScale, float aMain[4])
 345 {
 346   /* We want our matrix to look like this:
 347    * | dx  0  0|
 348    * |  0 dy  0|
 349    * |  0  0  1|
 350    * So A = value
 351    */
 352   aMain[0] = aXScale;
 353   aMain[3] = aYScale;
 354 }
 355
 356 /* Process a scalex function. */
 357 static void ProcessScaleX(float aMain[4], const nsCSSValue::Array* aData)
 358 {
 359   NS_PRECONDITION(aData->Count() == 2, "Bad array!");
 360   ProcessScaleHelper(aData->Item(1).GetFloatValue(), 1.0f, aMain);
 361 }
 362
 363 /* Process a scaley function. */
 364 static void ProcessScaleY(float aMain[4], const nsCSSValue::Array* aData)
 365 {
 366   NS_PRECONDITION(aData->Count() == 2, "Bad array!");
 367   ProcessScaleHelper(1.0f, aData->Item(1).GetFloatValue(), aMain);
 368 }
 369
 370 /* Process a scale function. */
 371 static void ProcessScale(float aMain[4], const nsCSSValue::Array* aData)
 372 {
 373   NS_PRECONDITION(aData->Count() == 2 || aData->Count() == 3, "Bad array!");
 374   /* We either have one element or two.  If we have one, it's for both X and Y.
 375    * Otherwise it's one for each.
 376    */
 377   const nsCSSValue& scaleX = aData->Item(1);
 378   const nsCSSValue& scaleY = (aData->Count() == 2 ? scaleX :
 379                               aData->Item(2));
 380
 381   ProcessScaleHelper(scaleX.GetFloatValue(),
 382                      scaleY.GetFloatValue(), aMain);
 383 }
 384
 385 /* Helper function that, given a set of angles, constructs the appropriate
 386  * skew matrix.
 387  */
 388 static void ProcessSkewHelper(double aXAngle, double aYAngle, float aMain[4])
 389 {
 390   /* We want our matrix to look like this:
 391    * |  1           tan(ThetaX)  0|
 392    * |  tan(ThetaY) 1            0|
 393    * |  0           0            1|
 394    * However, to avoid infinite values, we'll use the SafeTangent function
 395    * instead of the C standard tan function.
 396    */
 397   aMain[2] = SafeTangent(aXAngle);
 398   aMain[1] = SafeTangent(aYAngle);
 399 }
 400
 401 /* Function that converts a skewx transform into a matrix. */
 402 static void ProcessSkewX(float aMain[4], const nsCSSValue::Array* aData)
 403 {
 404   NS_ASSERTION(aData->Count() == 2, "Bad array!");
 405   ProcessSkewHelper(aData->Item(1).GetAngleValueInRadians(), 0.0, aMain);
 406 }
 407
 408 /* Function that converts a skewy transform into a matrix. */
 409 static void ProcessSkewY(float aMain[4], const nsCSSValue::Array* aData)
 410 {
 411   NS_ASSERTION(aData->Count() == 2, "Bad array!");
 412   ProcessSkewHelper(0.0, aData->Item(1).GetAngleValueInRadians(), aMain);
 413 }
 414
 415 /* Function that converts a skew transform into a matrix. */
 416 static void ProcessSkew(float aMain[4], const nsCSSValue::Array* aData)
 417 {
 418   NS_ASSERTION(aData->Count() == 2 || aData->Count() == 3, "Bad array!");
 419
 420   double xSkew = aData->Item(1).GetAngleValueInRadians();
 421   double ySkew = (aData->Count() == 2
 422                   ? 0.0 : aData->Item(2).GetAngleValueInRadians());
 423
 424   ProcessSkewHelper(xSkew, ySkew, aMain);
 425 }
 426
 427 /* Function that converts a rotate transform into a matrix. */
 428 static void ProcessRotate(float aMain[4], const nsCSSValue::Array* aData)
 429 {
 430   NS_PRECONDITION(aData->Count() == 2, "Invalid array!");
 431
 432   /* We want our matrix to look like this:
 433    * |  cos(theta)  -sin(theta)  0|
 434    * |  sin(theta)   cos(theta)  0|
 435    * |           0            0  1|
 436    * (see http://www.w3.org/TR/SVG/coords.html#RotationDefined)
 437    */
 438   double theta = aData->Item(1).GetAngleValueInRadians();
 439   float cosTheta = FlushToZero(cos(theta));
 440   float sinTheta = FlushToZero(sin(theta));
 441
 442   aMain[0] = cosTheta;
 443   aMain[1] = sinTheta;
 444   aMain[2] = -sinTheta;
 445   aMain[3] = cosTheta;
 446 }
 447
 448 /**
 449  * SetToTransformFunction is essentially a giant switch statement that fans
 450  * out to many smaller helper functions.
 451  */
 452 void
 453 nsStyleTransformMatrix::SetToTransformFunction(const nsCSSValue::Array * aData,
 454                                                nsStyleContext* aContext,
 455                                                nsPresContext* aPresContext,
 456                                                PRBool& aCanStoreInRuleTree)
 457 {
 458   NS_PRECONDITION(aData, "Why did you want to get data from a null array?");
 459   NS_PRECONDITION(aContext, "Need a context for unit conversion!");
 460   NS_PRECONDITION(aPresContext, "Need a context for unit conversion!");
 461
 462   /* Reset the matrix to the identity so that each subfunction can just
 463    * worry about its own components.
 464    */
 465   SetToIdentity();
 466
 467   /* Get the keyword for the transform. */
 468   nsAutoString keyword;
 469   aData->Item(0).GetStringValue(keyword);
 470   switch (nsCSSKeywords::LookupKeyword(keyword)) {
 471   case eCSSKeyword_translatex:
 472     ProcessTranslateX(mDelta, mX, aData, aContext, aPresContext,
 473                       aCanStoreInRuleTree);
 474     break;
 475   case eCSSKeyword_translatey:
 476     ProcessTranslateY(mDelta, mY, aData, aContext, aPresContext,
 477                       aCanStoreInRuleTree);
 478     break;
 479   case eCSSKeyword_translate:
 480     ProcessTranslate(mDelta, mX, mY, aData, aContext, aPresContext,
 481                      aCanStoreInRuleTree);
 482     break;
 483   case eCSSKeyword_scalex:
 484     ProcessScaleX(mMain, aData);
 485     break;
 486   case eCSSKeyword_scaley:
 487     ProcessScaleY(mMain, aData);
 488     break;
 489   case eCSSKeyword_scale:
 490     ProcessScale(mMain, aData);
 491     break;
 492   case eCSSKeyword_skewx:
 493     ProcessSkewX(mMain, aData);
 494     break;
 495   case eCSSKeyword_skewy:
 496     ProcessSkewY(mMain, aData);
 497     break;
 498   case eCSSKeyword_skew:
 499     ProcessSkew(mMain, aData);
 500     break;
 501   case eCSSKeyword_rotate:
 502     ProcessRotate(mMain, aData);
 503     break;
 504   case eCSSKeyword_matrix:
 505     ProcessMatrix(mMain, mDelta, mX, mY, aData, aContext, aPresContext,
 506                   aCanStoreInRuleTree);
 507     break;
 508   default:
 509     NS_NOTREACHED("Unknown transform function!");
 510   }
 511 }
 512
 513 /* Does an element-by-element comparison and returns whether or not the
 514  * matrices are equal.
 515  */
 516 PRBool
 517 nsStyleTransformMatrix::operator ==(const nsStyleTransformMatrix &aOther) const
 518 {
 519   for (PRInt32 index = 0; index < 4; ++index)
 520     if (mMain[index] != aOther.mMain[index])
 521       return PR_FALSE;
 522
 523   for (PRInt32 index = 0; index < 2; ++index)
 524     if (mDelta[index] != aOther.mDelta[index] ||
 525         mX[index] != aOther.mX[index] ||
 526         mY[index] != aOther.mY[index])
 527       return PR_FALSE;
 528
 529   return PR_TRUE;
 530 }