layout/style/nsStyleStruct.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  * Netscape Communications Corporation.
  19  * Portions created by the Initial Developer are Copyright (C) 1998
  20  * the Initial Developer. All Rights Reserved.
  21  *
  22  * Contributor(s):
  23  *   David Hyatt (hyatt@netscape.com)
  24  *   Mats Palmgren <mats.palmgren@bredband.net>
  25  *   Michael Ventnor <m.ventnor@gmail.com>
  26  *
  27  * Alternatively, the contents of this file may be used under the terms of
  28  * either of the GNU General Public License Version 2 or later (the "GPL"),
  29  * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  30  * in which case the provisions of the GPL or the LGPL are applicable instead
  31  * of those above. If you wish to allow use of your version of this file only
  32  * under the terms of either the GPL or the LGPL, and not to allow others to
  33  * use your version of this file under the terms of the MPL, indicate your
  34  * decision by deleting the provisions above and replace them with the notice
  35  * and other provisions required by the GPL or the LGPL. If you do not delete
  36  * the provisions above, a recipient may use your version of this file under
  37  * the terms of any one of the MPL, the GPL or the LGPL.
  38  *
  39  * ***** END LICENSE BLOCK ***** */
  40
  41 /*
  42  * structs that contain the data provided by nsStyleContext, the
  43  * internal API for computed style data for an element
  44  */
  45
  46 #include "nsStyleStruct.h"
  47 #include "nsStyleStructInlines.h"
  48 #include "nsStyleConsts.h"
  49 #include "nsThemeConstants.h"
  50 #include "nsString.h"
  51 #include "nsPresContext.h"
  52 #include "nsIDeviceContext.h"
  53 #include "nsIStyleRule.h"
  54 #include "nsCRT.h"
  55
  56 #include "nsCOMPtr.h"
  57 #include "nsIPresShell.h"
  58 #include "nsIFrame.h"
  59 #include "nsHTMLReflowState.h"
  60 #include "prenv.h"
  61
  62 #include "nsBidiUtils.h"
  63
  64 #include "imgIRequest.h"
  65 #include "prlog.h"
  66
  67 // Make sure we have enough bits in NS_STYLE_INHERIT_MASK.
  68 PR_STATIC_ASSERT((((1 << nsStyleStructID_Length) - 1) &
  69                   ~(NS_STYLE_INHERIT_MASK)) == 0);
  70
  71 inline PRBool IsFixedUnit(nsStyleUnit aUnit, PRBool aEnumOK)
  72 {
  73   return PRBool((aUnit == eStyleUnit_Coord) ||
  74                 (aEnumOK && (aUnit == eStyleUnit_Enumerated)));
  75 }
  76
  77 static PRBool EqualURIs(nsIURI *aURI1, nsIURI *aURI2)
  78 {
  79   PRBool eq;
  80   return aURI1 == aURI2 ||    // handle null==null, and optimize
  81          (aURI1 && aURI2 &&
  82           NS_SUCCEEDED(aURI1->Equals(aURI2, &eq)) && // not equal on fail
  83           eq);
  84 }
  85
  86 static PRBool EqualURIs(nsCSSValue::URL *aURI1, nsCSSValue::URL *aURI2)
  87 {
  88   return aURI1 == aURI2 ||    // handle null==null, and optimize
  89          (aURI1 && aURI2 && aURI1->URIEquals(*aURI2));
  90 }
  91
  92 static PRBool EqualImages(imgIRequest *aImage1, imgIRequest* aImage2)
  93 {
  94   if (aImage1 == aImage2) {
  95     return PR_TRUE;
  96   }
  97
  98   if (!aImage1 || !aImage2) {
  99     return PR_FALSE;
 100   }
 101
 102   nsCOMPtr<nsIURI> uri1, uri2;
 103   aImage1->GetURI(getter_AddRefs(uri1));
 104   aImage2->GetURI(getter_AddRefs(uri2));
 105   return EqualURIs(uri1, uri2);
 106 }
 107
 108 static nsChangeHint CalcShadowDifference(nsCSSShadowArray* lhs,
 109                                          nsCSSShadowArray* rhs);
 110
 111 // --------------------
 112 // nsStyleFont
 113 //
 114 nsStyleFont::nsStyleFont(const nsFont& aFont, nsPresContext *aPresContext)
 115   : mFont(aFont),
 116     mGenericID(kGenericFont_NONE)
 117 {
 118   mSize = mFont.size = nsStyleFont::ZoomText(aPresContext, mFont.size);
 119 #ifdef MOZ_MATHML
 120   mScriptUnconstrainedSize = mSize;
 121   mScriptMinSize = aPresContext->TwipsToAppUnits(
 122       NS_POINTS_TO_TWIPS(NS_MATHML_DEFAULT_SCRIPT_MIN_SIZE_PT));
 123   mScriptLevel = 0;
 124   mScriptSizeMultiplier = NS_MATHML_DEFAULT_SCRIPT_SIZE_MULTIPLIER;
 125 #endif
 126 }
 127
 128 nsStyleFont::nsStyleFont(const nsStyleFont& aSrc)
 129   : mFont(aSrc.mFont)
 130   , mSize(aSrc.mSize)
 131   , mGenericID(aSrc.mGenericID)
 132 #ifdef MOZ_MATHML
 133   , mScriptLevel(aSrc.mScriptLevel)
 134   , mScriptUnconstrainedSize(aSrc.mScriptUnconstrainedSize)
 135   , mScriptMinSize(aSrc.mScriptMinSize)
 136   , mScriptSizeMultiplier(aSrc.mScriptSizeMultiplier)
 137 #endif
 138 {
 139 }
 140
 141 nsStyleFont::nsStyleFont(nsPresContext* aPresContext)
 142   : mFont(*(aPresContext->GetDefaultFont(kPresContext_DefaultVariableFont_ID))),
 143     mGenericID(kGenericFont_NONE)
 144 {
 145   mSize = mFont.size = nsStyleFont::ZoomText(aPresContext, mFont.size);
 146 #ifdef MOZ_MATHML
 147   mScriptUnconstrainedSize = mSize;
 148   mScriptMinSize = aPresContext->TwipsToAppUnits(
 149       NS_POINTS_TO_TWIPS(NS_MATHML_DEFAULT_SCRIPT_MIN_SIZE_PT));
 150   mScriptLevel = 0;
 151   mScriptSizeMultiplier = NS_MATHML_DEFAULT_SCRIPT_SIZE_MULTIPLIER;
 152 #endif
 153 }
 154
 155 void*
 156 nsStyleFont::operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
 157   void* result = aContext->AllocateFromShell(sz);
 158   if (result)
 159     memset(result, 0, sz);
 160   return result;
 161 }
 162
 163 void
 164 nsStyleFont::Destroy(nsPresContext* aContext) {
 165   this->~nsStyleFont();
 166   aContext->FreeToShell(sizeof(nsStyleFont), this);
 167 }
 168
 169 nsChangeHint nsStyleFont::CalcDifference(const nsStyleFont& aOther) const
 170 {
 171   if (mSize == aOther.mSize) {
 172     return CalcFontDifference(mFont, aOther.mFont);
 173   }
 174   return NS_STYLE_HINT_REFLOW;
 175 }
 176
 177 #ifdef DEBUG
 178 /* static */
 179 nsChangeHint nsStyleFont::MaxDifference()
 180 {
 181   return NS_STYLE_HINT_REFLOW;
 182 }
 183 #endif
 184
 185 /* static */ nscoord
 186 nsStyleFont::ZoomText(nsPresContext *aPresContext, nscoord aSize)
 187 {
 188   return nscoord(float(aSize) * aPresContext->TextZoom());
 189 }
 190
 191 /* static */ nscoord
 192 nsStyleFont::UnZoomText(nsPresContext *aPresContext, nscoord aSize)
 193 {
 194   return nscoord(float(aSize) / aPresContext->TextZoom());
 195 }
 196
 197 nsChangeHint nsStyleFont::CalcFontDifference(const nsFont& aFont1, const nsFont& aFont2)
 198 {
 199   if ((aFont1.size == aFont2.size) &&
 200       (aFont1.sizeAdjust == aFont2.sizeAdjust) &&
 201       (aFont1.style == aFont2.style) &&
 202       (aFont1.variant == aFont2.variant) &&
 203       (aFont1.familyNameQuirks == aFont2.familyNameQuirks) &&
 204       (aFont1.weight == aFont2.weight) &&
 205       (aFont1.name == aFont2.name)) {
 206     if ((aFont1.decorations == aFont2.decorations)) {
 207       return NS_STYLE_HINT_NONE;
 208     }
 209     return NS_STYLE_HINT_VISUAL;
 210   }
 211   return NS_STYLE_HINT_REFLOW;
 212 }
 213
 214 static PRBool IsFixedData(const nsStyleSides& aSides, PRBool aEnumOK)
 215 {
 216   NS_FOR_CSS_SIDES(side) {
 217     if (!IsFixedUnit(aSides.GetUnit(side), aEnumOK))
 218       return PR_FALSE;
 219   }
 220   return PR_TRUE;
 221 }
 222
 223 static nscoord CalcCoord(const nsStyleCoord& aCoord,
 224                          const nscoord* aEnumTable,
 225                          PRInt32 aNumEnums)
 226 {
 227   switch (aCoord.GetUnit()) {
 228     case eStyleUnit_Coord:
 229       return aCoord.GetCoordValue();
 230     case eStyleUnit_Enumerated:
 231       if (nsnull != aEnumTable) {
 232         PRInt32 value = aCoord.GetIntValue();
 233         if ((0 <= value) && (value < aNumEnums)) {
 234           return aEnumTable[aCoord.GetIntValue()];
 235         }
 236       }
 237       break;
 238     default:
 239       NS_ERROR("bad unit type");
 240       break;
 241   }
 242   return 0;
 243 }
 244
 245 nsStyleMargin::nsStyleMargin() {
 246   nsStyleCoord zero(0);
 247   NS_FOR_CSS_SIDES(side) {
 248     mMargin.Set(side, zero);
 249   }
 250   mHasCachedMargin = PR_FALSE;
 251 }
 252
 253 nsStyleMargin::nsStyleMargin(const nsStyleMargin& aSrc) {
 254   mMargin = aSrc.mMargin;
 255   mHasCachedMargin = PR_FALSE;
 256 }
 257
 258 void*
 259 nsStyleMargin::operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
 260   void* result = aContext->AllocateFromShell(sz);
 261   if (result)
 262     memset(result, 0, sz);
 263   return result;
 264 }
 265
 266 void
 267 nsStyleMargin::Destroy(nsPresContext* aContext) {
 268   this->~nsStyleMargin();
 269   aContext->FreeToShell(sizeof(nsStyleMargin), this);
 270 }
 271
 272
 273 void nsStyleMargin::RecalcData()
 274 {
 275   if (IsFixedData(mMargin, PR_FALSE)) {
 276     NS_FOR_CSS_SIDES(side) {
 277       mCachedMargin.side(side) = CalcCoord(mMargin.Get(side), nsnull, 0);
 278     }
 279     mHasCachedMargin = PR_TRUE;
 280   }
 281   else
 282     mHasCachedMargin = PR_FALSE;
 283 }
 284
 285 nsChangeHint nsStyleMargin::CalcDifference(const nsStyleMargin& aOther) const
 286 {
 287   if (mMargin == aOther.mMargin) {
 288     return NS_STYLE_HINT_NONE;
 289   }
 290   return NS_STYLE_HINT_REFLOW;
 291 }
 292
 293 #ifdef DEBUG
 294 /* static */
 295 nsChangeHint nsStyleMargin::MaxDifference()
 296 {
 297   return NS_STYLE_HINT_REFLOW;
 298 }
 299 #endif
 300
 301 nsStylePadding::nsStylePadding() {
 302   nsStyleCoord zero(0);
 303   NS_FOR_CSS_SIDES(side) {
 304     mPadding.Set(side, zero);
 305   }
 306   mHasCachedPadding = PR_FALSE;
 307 }
 308
 309 nsStylePadding::nsStylePadding(const nsStylePadding& aSrc) {
 310   mPadding = aSrc.mPadding;
 311   mHasCachedPadding = PR_FALSE;
 312 }
 313
 314 void*
 315 nsStylePadding::operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
 316   void* result = aContext->AllocateFromShell(sz);
 317   if (result)
 318     memset(result, 0, sz);
 319   return result;
 320 }
 321
 322 void
 323 nsStylePadding::Destroy(nsPresContext* aContext) {
 324   this->~nsStylePadding();
 325   aContext->FreeToShell(sizeof(nsStylePadding), this);
 326 }
 327
 328 void nsStylePadding::RecalcData()
 329 {
 330   if (IsFixedData(mPadding, PR_FALSE)) {
 331     NS_FOR_CSS_SIDES(side) {
 332       mCachedPadding.side(side) = CalcCoord(mPadding.Get(side), nsnull, 0);
 333     }
 334     mHasCachedPadding = PR_TRUE;
 335   }
 336   else
 337     mHasCachedPadding = PR_FALSE;
 338 }
 339
 340 nsChangeHint nsStylePadding::CalcDifference(const nsStylePadding& aOther) const
 341 {
 342   if (mPadding == aOther.mPadding) {
 343     return NS_STYLE_HINT_NONE;
 344   }
 345   return NS_STYLE_HINT_REFLOW;
 346 }
 347
 348 #ifdef DEBUG
 349 /* static */
 350 nsChangeHint nsStylePadding::MaxDifference()
 351 {
 352   return NS_STYLE_HINT_REFLOW;
 353 }
 354 #endif
 355
 356 nsStyleBorder::nsStyleBorder(nsPresContext* aPresContext)
 357   : mHaveBorderImageWidth(PR_FALSE),
 358     mComputedBorder(0, 0, 0, 0),
 359     mBorderImage(nsnull)
 360 {
 361   nscoord medium =
 362     (aPresContext->GetBorderWidthTable())[NS_STYLE_BORDER_WIDTH_MEDIUM];
 363   NS_FOR_CSS_SIDES(side) {
 364     mBorder.side(side) = medium;
 365     mBorderStyle[side] = NS_STYLE_BORDER_STYLE_NONE | BORDER_COLOR_FOREGROUND;
 366     mBorderColor[side] = NS_RGB(0, 0, 0);
 367   }
 368   NS_FOR_CSS_HALF_CORNERS(corner) {
 369     mBorderRadius.Set(corner, nsStyleCoord(0));
 370   }
 371
 372   mBorderColors = nsnull;
 373   mBoxShadow = nsnull;
 374
 375   mFloatEdge = NS_STYLE_FLOAT_EDGE_CONTENT;
 376
 377   mTwipsPerPixel = aPresContext->DevPixelsToAppUnits(1);
 378 }
 379
 380 nsBorderColors::~nsBorderColors()
 381 {
 382   NS_CSS_DELETE_LIST_MEMBER(nsBorderColors, this, mNext);
 383 }
 384
 385 nsBorderColors*
 386 nsBorderColors::Clone(PRBool aDeep) const
 387 {
 388   nsBorderColors* result = new nsBorderColors(mColor);
 389   if (NS_UNLIKELY(!result))
 390     return result;
 391   if (aDeep)
 392     NS_CSS_CLONE_LIST_MEMBER(nsBorderColors, this, mNext, result, (PR_FALSE));
 393   return result;
 394 }
 395
 396 nsStyleBorder::nsStyleBorder(const nsStyleBorder& aSrc)
 397   : mBorderRadius(aSrc.mBorderRadius),
 398     mBorderImageSplit(aSrc.mBorderImageSplit),
 399     mFloatEdge(aSrc.mFloatEdge),
 400     mBorderImageHFill(aSrc.mBorderImageHFill),
 401     mBorderImageVFill(aSrc.mBorderImageVFill),
 402     mBorderColors(nsnull),
 403     mBoxShadow(aSrc.mBoxShadow),
 404     mHaveBorderImageWidth(aSrc.mHaveBorderImageWidth),
 405     mBorderImageWidth(aSrc.mBorderImageWidth),
 406     mComputedBorder(aSrc.mComputedBorder),
 407     mBorder(aSrc.mBorder),
 408     mBorderImage(aSrc.mBorderImage),
 409     mTwipsPerPixel(aSrc.mTwipsPerPixel)
 410 {
 411   if (aSrc.mBorderColors) {
 412     EnsureBorderColors();
 413     for (PRInt32 i = 0; i < 4; i++)
 414       if (aSrc.mBorderColors[i])
 415         mBorderColors[i] = aSrc.mBorderColors[i]->Clone();
 416       else
 417         mBorderColors[i] = nsnull;
 418   }
 419
 420   NS_FOR_CSS_SIDES(side) {
 421     mBorderStyle[side] = aSrc.mBorderStyle[side];
 422     mBorderColor[side] = aSrc.mBorderColor[side];
 423   }
 424   NS_FOR_CSS_HALF_CORNERS(corner) {
 425     mBorderRadius.Set(corner, aSrc.mBorderRadius.Get(corner));
 426   }
 427 }
 428
 429 nsStyleBorder::~nsStyleBorder()
 430 {
 431   if (mBorderColors) {
 432     for (PRInt32 i = 0; i < 4; i++)
 433       delete mBorderColors[i];
 434     delete [] mBorderColors;
 435   }
 436 }
 437
 438 void*
 439 nsStyleBorder::operator new(size_t sz, nsPresContext* aContext) CPP_THROW_NEW {
 440   void* result = aContext->AllocateFromShell(sz);
 441   if (result)
 442     memset(result, 0, sz);
 443   return result;
 444 }
 445
 446 void
 447 nsStyleBorder::Destroy(nsPresContext* aContext) {
 448   this->~nsStyleBorder();
 449   aContext->FreeToShell(sizeof(nsStyleBorder), this);
 450 }
 451
 452
 453 nsChangeHint nsStyleBorder::CalcDifference(const nsStyleBorder& aOther) const
 454 {
 455   nsChangeHint shadowDifference =
 456     CalcShadowDifference(mBoxShadow, aOther.mBoxShadow);
 457
 458   // Note that differences in mBorder don't affect rendering (which should only
 459   // use mComputedBorder), so don't need to be tested for here.
 460   if (mTwipsPerPixel != aOther.mTwipsPerPixel ||
 461       GetActualBorder() != aOther.GetActualBorder() ||
 462       mFloatEdge != aOther.mFloatEdge ||
 463       (shadowDifference & nsChangeHint_ReflowFrame))
 464     return NS_STYLE_HINT_REFLOW;
 465
 466   // Note that mBorderStyle stores not only the border style but also
 467   // color-related flags.  Given that we've already done an mComputedBorder
 468   // comparison, border-style differences can only lead to a VISUAL hint.  So
 469   // it's OK to just compare the values directly -- if either the actual
 470   // style or the color flags differ we want to repaint.
 471   NS_FOR_CSS_SIDES(ix) {
 472     if (mBorderStyle[ix] != aOther.mBorderStyle[ix] ||
 473         mBorderColor[ix] != aOther.mBorderColor[ix])
 474       return NS_STYLE_HINT_VISUAL;
 475   }
 476
 477   if (mBorderRadius != aOther.mBorderRadius ||
 478       !mBorderColors != !aOther.mBorderColors)
 479     return NS_STYLE_HINT_VISUAL;
 480
 481   if (IsBorderImageLoaded() || aOther.IsBorderImageLoaded()) {
 482     if (mBorderImage != aOther.mBorderImage ||
 483         mBorderImageHFill != aOther.mBorderImageHFill ||
 484         mBorderImageVFill != aOther.mBorderImageVFill ||
 485         mBorderImageSplit != aOther.mBorderImageSplit)
 486       return NS_STYLE_HINT_VISUAL;
 487     // The call to GetActualBorder above already considered
 488     // mBorderImageWidth and mHaveBorderImageWidth.
 489   }
 490
 491   // Note that at this point if mBorderColors is non-null so is
 492   // aOther.mBorderColors
 493   if (mBorderColors) {
 494     NS_FOR_CSS_SIDES(ix) {
 495       if (!nsBorderColors::Equal(mBorderColors[ix],
 496                                  aOther.mBorderColors[ix]))
 497         return NS_STYLE_HINT_VISUAL;
 498     }
 499   }
 500
 501   return shadowDifference;
 502 }
 503
 504 #ifdef DEBUG
 505 /* static */
 506 nsChangeHint nsStyleBorder::MaxDifference()
 507 {
 508   return NS_STYLE_HINT_REFLOW;
 509 }
 510 #endif
 511
 512 PRBool
 513 nsStyleBorder::ImageBorderDiffers() const
 514 {
 515   return mComputedBorder !=
 516            (mHaveBorderImageWidth ? mBorderImageWidth : mBorder);
 517 }
 518
 519 const nsMargin&
 520 nsStyleBorder::GetActualBorder() const
 521 {
 522   if (IsBorderImageLoaded())
 523     if (mHaveBorderImageWidth)
 524       return mBorderImageWidth;
 525     else
 526       return mBorder;
 527   else
 528     return mComputedBorder;
 529 }
 530
 531 nsStyleOutline::nsStyleOutline(nsPresContext* aPresContext)
 532 {
 533   // spacing values not inherited
 534   nsStyleCoord zero(0);
 535   NS_FOR_CSS_HALF_CORNERS(corner) {
 536     mOutlineRadius.Set(corner, zero);
 537   }
 538
 539   mOutlineOffset = 0;
 540
 541   mOutlineWidth = nsStyleCoord(NS_STYLE_BORDER_WIDTH_MEDIUM, eStyleUnit_Enumerated);
 542   mOutlineStyle = NS_STYLE_BORDER_STYLE_NONE;
 543   mOutlineColor = NS_RGB(0, 0, 0);
 544
 545   mHasCachedOutline = PR_FALSE;
 546   mTwipsPerPixel = aPresContext->DevPixelsToAppUnits(1);
 547 }
 548
 549 nsStyleOutline::nsStyleOutline(const nsStyleOutline& aSrc) {
 550   memcpy((nsStyleOutline*)this, &aSrc, sizeof(nsStyleOutline));
 551 }
 552
 553 void
 554 nsStyleOutline::RecalcData(nsPresContext* aContext)
 555 {
 556   if (NS_STYLE_BORDER_STYLE_NONE == GetOutlineStyle()) {
 557     mCachedOutlineWidth = 0;
 558     mHasCachedOutline = PR_TRUE;
 559   } else if (IsFixedUnit(mOutlineWidth.GetUnit(), PR_TRUE)) {
 560     mCachedOutlineWidth =
 561       CalcCoord(mOutlineWidth, aContext->GetBorderWidthTable(), 3);
 562     mCachedOutlineWidth =
 563       NS_ROUND_BORDER_TO_PIXELS(mCachedOutlineWidth, mTwipsPerPixel);
 564     mHasCachedOutline = PR_TRUE;
 565   }
 566   else
 567     mHasCachedOutline = PR_FALSE;
 568 }
 569
 570 nsChangeHint nsStyleOutline::CalcDifference(const nsStyleOutline& aOther) const
 571 {
 572   PRBool outlineWasVisible =
 573     mCachedOutlineWidth > 0 && mOutlineStyle != NS_STYLE_BORDER_STYLE_NONE;
 574   PRBool outlineIsVisible =
 575     aOther.mCachedOutlineWidth > 0 && aOther.mOutlineStyle != NS_STYLE_BORDER_STYLE_NONE;
 576   if (outlineWasVisible != outlineIsVisible ||
 577       (outlineIsVisible && (mOutlineOffset != aOther.mOutlineOffset ||
 578                             mOutlineWidth != aOther.mOutlineWidth ||
 579                             mTwipsPerPixel != aOther.mTwipsPerPixel))) {
 580     return NS_CombineHint(nsChangeHint_ReflowFrame, nsChangeHint_RepaintFrame);
 581   }
 582   if ((mOutlineStyle != aOther.mOutlineStyle) ||
 583       (mOutlineColor != aOther.mOutlineColor) ||
 584       (mOutlineRadius != aOther.mOutlineRadius)) {
 585     return nsChangeHint_RepaintFrame;
 586   }
 587   return NS_STYLE_HINT_NONE;
 588 }
 589
 590 #ifdef DEBUG
 591 /* static */
 592 nsChangeHint nsStyleOutline::MaxDifference()
 593 {
 594   return NS_CombineHint(nsChangeHint_ReflowFrame, nsChangeHint_RepaintFrame);
 595 }
 596 #endif
 597
 598 // --------------------
 599 // nsStyleList
 600 //
 601 nsStyleList::nsStyleList()
 602   : mListStyleType(NS_STYLE_LIST_STYLE_DISC),
 603     mListStylePosition(NS_STYLE_LIST_STYLE_POSITION_OUTSIDE)
 604 {
 605 }
 606
 607 nsStyleList::~nsStyleList()
 608 {
 609 }
 610
 611 nsStyleList::nsStyleList(const nsStyleList& aSource)
 612   : mListStyleType(aSource.mListStyleType),
 613     mListStylePosition(aSource.mListStylePosition),
 614     mListStyleImage(aSource.mListStyleImage),
 615     mImageRegion(aSource.mImageRegion)
 616 {
 617 }
 618
 619 nsChangeHint nsStyleList::CalcDifference(const nsStyleList& aOther) const
 620 {
 621   if (mListStylePosition != aOther.mListStylePosition)
 622     return NS_STYLE_HINT_FRAMECHANGE;
 623   if (EqualImages(mListStyleImage, aOther.mListStyleImage) &&
 624       mListStyleType == aOther.mListStyleType) {
 625     if (mImageRegion == aOther.mImageRegion)
 626       return NS_STYLE_HINT_NONE;
 627     if (mImageRegion.width == aOther.mImageRegion.width &&
 628         mImageRegion.height == aOther.mImageRegion.height)
 629       return NS_STYLE_HINT_VISUAL;
 630   }
 631   return NS_STYLE_HINT_REFLOW;
 632 }
 633
 634 #ifdef DEBUG
 635 /* static */
 636 nsChangeHint nsStyleList::MaxDifference()
 637 {
 638   return NS_STYLE_HINT_FRAMECHANGE;
 639 }
 640 #endif
 641
 642 // --------------------
 643 // nsStyleXUL
 644 //
 645 nsStyleXUL::nsStyleXUL()
 646 {
 647   mBoxAlign  = NS_STYLE_BOX_ALIGN_STRETCH;
 648   mBoxDirection = NS_STYLE_BOX_DIRECTION_NORMAL;
 649   mBoxFlex = 0.0f;
 650   mBoxOrient = NS_STYLE_BOX_ORIENT_HORIZONTAL;
 651   mBoxPack   = NS_STYLE_BOX_PACK_START;
 652   mBoxOrdinal = 1;
 653   mStretchStack = PR_TRUE;
 654 }
 655
 656 nsStyleXUL::~nsStyleXUL()
 657 {
 658 }
 659
 660 nsStyleXUL::nsStyleXUL(const nsStyleXUL& aSource)
 661 {
 662   memcpy((nsStyleXUL*)this, &aSource, sizeof(nsStyleXUL));
 663 }
 664
 665 nsChangeHint nsStyleXUL::CalcDifference(const nsStyleXUL& aOther) const
 666 {
 667   if (mBoxAlign == aOther.mBoxAlign &&
 668       mBoxDirection == aOther.mBoxDirection &&
 669       mBoxFlex == aOther.mBoxFlex &&
 670       mBoxOrient == aOther.mBoxOrient &&
 671       mBoxPack == aOther.mBoxPack &&
 672       mBoxOrdinal == aOther.mBoxOrdinal)
 673     return NS_STYLE_HINT_NONE;
 674   if (mBoxOrdinal != aOther.mBoxOrdinal)
 675     return NS_STYLE_HINT_FRAMECHANGE;
 676   return NS_STYLE_HINT_REFLOW;
 677 }
 678
 679 #ifdef DEBUG
 680 /* static */
 681 nsChangeHint nsStyleXUL::MaxDifference()
 682 {
 683   return NS_STYLE_HINT_FRAMECHANGE;
 684 }
 685 #endif
 686
 687 // --------------------
 688 // nsStyleColumn
 689 //
 690 nsStyleColumn::nsStyleColumn(nsPresContext* aPresContext)
 691 {
 692   mColumnCount = NS_STYLE_COLUMN_COUNT_AUTO;
 693   mColumnWidth.SetAutoValue();
 694   mColumnGap.SetNormalValue();
 695
 696   mColumnRuleWidth = (aPresContext->GetBorderWidthTable())[NS_STYLE_BORDER_WIDTH_MEDIUM];
 697   mColumnRuleStyle = NS_STYLE_BORDER_STYLE_NONE;
 698   mColumnRuleColor = NS_RGB(0, 0, 0);
 699   mColumnRuleColorIsForeground = PR_TRUE;
 700
 701   mTwipsPerPixel = aPresContext->AppUnitsPerDevPixel();
 702 }
 703
 704 nsStyleColumn::~nsStyleColumn()
 705 {
 706 }
 707
 708 nsStyleColumn::nsStyleColumn(const nsStyleColumn& aSource)
 709 {
 710   memcpy((nsStyleColumn*)this, &aSource, sizeof(nsStyleColumn));
 711 }
 712
 713 nsChangeHint nsStyleColumn::CalcDifference(const nsStyleColumn& aOther) const
 714 {
 715   if ((mColumnWidth.GetUnit() == eStyleUnit_Auto)
 716       != (aOther.mColumnWidth.GetUnit() == eStyleUnit_Auto) ||
 717       mColumnCount != aOther.mColumnCount)
 718     // We force column count changes to do a reframe, because it's tricky to handle
 719     // some edge cases where the column count gets smaller and content overflows.
 720     // XXX not ideal
 721     return NS_STYLE_HINT_FRAMECHANGE;
 722
 723   if (mColumnWidth != aOther.mColumnWidth ||
 724       mColumnGap != aOther.mColumnGap)
 725     return NS_STYLE_HINT_REFLOW;
 726
 727   if (GetComputedColumnRuleWidth() != aOther.GetComputedColumnRuleWidth() ||
 728       mColumnRuleStyle != aOther.mColumnRuleStyle ||
 729       mColumnRuleColor != aOther.mColumnRuleColor ||
 730       mColumnRuleColorIsForeground != aOther.mColumnRuleColorIsForeground)
 731     return NS_STYLE_HINT_VISUAL;
 732
 733   return NS_STYLE_HINT_NONE;
 734 }
 735
 736 #ifdef DEBUG
 737 /* static */
 738 nsChangeHint nsStyleColumn::MaxDifference()
 739 {
 740   return NS_STYLE_HINT_FRAMECHANGE;
 741 }
 742 #endif
 743
 744 #ifdef MOZ_SVG
 745 // --------------------
 746 // nsStyleSVG
 747 //
 748 nsStyleSVG::nsStyleSVG()
 749 {
 750     mFill.mType              = eStyleSVGPaintType_Color;
 751     mFill.mPaint.mColor      = NS_RGB(0,0,0);
 752     mFill.mFallbackColor     = NS_RGB(0,0,0);
 753     mStroke.mType            = eStyleSVGPaintType_None;
 754     mStroke.mPaint.mColor    = NS_RGB(0,0,0);
 755     mStroke.mFallbackColor   = NS_RGB(0,0,0);
 756     mStrokeDasharray         = nsnull;
 757
 758     mStrokeDashoffset.SetCoordValue(0);
 759     mStrokeWidth.SetCoordValue(nsPresContext::CSSPixelsToAppUnits(1));
 760
 761     mFillOpacity             = 1.0f;
 762     mStrokeMiterlimit        = 4.0f;
 763     mStrokeOpacity           = 1.0f;
 764
 765     mStrokeDasharrayLength   = 0;
 766     mClipRule                = NS_STYLE_FILL_RULE_NONZERO;
 767     mColorInterpolation      = NS_STYLE_COLOR_INTERPOLATION_SRGB;
 768     mColorInterpolationFilters = NS_STYLE_COLOR_INTERPOLATION_LINEARRGB;
 769     mFillRule                = NS_STYLE_FILL_RULE_NONZERO;
 770     mPointerEvents           = NS_STYLE_POINTER_EVENTS_VISIBLEPAINTED;
 771     mShapeRendering          = NS_STYLE_SHAPE_RENDERING_AUTO;
 772     mStrokeLinecap           = NS_STYLE_STROKE_LINECAP_BUTT;
 773     mStrokeLinejoin          = NS_STYLE_STROKE_LINEJOIN_MITER;
 774     mTextAnchor              = NS_STYLE_TEXT_ANCHOR_START;
 775     mTextRendering           = NS_STYLE_TEXT_RENDERING_AUTO;
 776 }
 777
 778 nsStyleSVG::~nsStyleSVG()
 779 {
 780   delete [] mStrokeDasharray;
 781 }
 782
 783 nsStyleSVG::nsStyleSVG(const nsStyleSVG& aSource)
 784 {
 785   //memcpy((nsStyleSVG*)this, &aSource, sizeof(nsStyleSVG));
 786
 787   mFill = aSource.mFill;
 788   mStroke = aSource.mStroke;
 789
 790   mMarkerEnd = aSource.mMarkerEnd;
 791   mMarkerMid = aSource.mMarkerMid;
 792   mMarkerStart = aSource.mMarkerStart;
 793
 794   mStrokeDasharrayLength = aSource.mStrokeDasharrayLength;
 795   if (aSource.mStrokeDasharray) {
 796     mStrokeDasharray = new nsStyleCoord[mStrokeDasharrayLength];
 797     if (mStrokeDasharray)
 798       memcpy(mStrokeDasharray,
 799              aSource.mStrokeDasharray,
 800              mStrokeDasharrayLength * sizeof(nsStyleCoord));
 801     else
 802       mStrokeDasharrayLength = 0;
 803   } else {
 804     mStrokeDasharray = nsnull;
 805   }
 806
 807   mStrokeDashoffset = aSource.mStrokeDashoffset;
 808   mStrokeWidth = aSource.mStrokeWidth;
 809
 810   mFillOpacity = aSource.mFillOpacity;
 811   mStrokeMiterlimit = aSource.mStrokeMiterlimit;
 812   mStrokeOpacity = aSource.mStrokeOpacity;
 813
 814   mClipRule = aSource.mClipRule;
 815   mColorInterpolation = aSource.mColorInterpolation;
 816   mColorInterpolationFilters = aSource.mColorInterpolationFilters;
 817   mFillRule = aSource.mFillRule;
 818   mPointerEvents = aSource.mPointerEvents;
 819   mShapeRendering = aSource.mShapeRendering;
 820   mStrokeLinecap = aSource.mStrokeLinecap;
 821   mStrokeLinejoin = aSource.mStrokeLinejoin;
 822   mTextAnchor = aSource.mTextAnchor;
 823   mTextRendering = aSource.mTextRendering;
 824 }
 825
 826 static PRBool PaintURIChanged(const nsStyleSVGPaint& aPaint1,
 827                               const nsStyleSVGPaint& aPaint2)
 828 {
 829   if (aPaint1.mType != aPaint2.mType) {
 830     return aPaint1.mType == eStyleSVGPaintType_Server ||
 831            aPaint2.mType == eStyleSVGPaintType_Server;
 832   }
 833   return aPaint1.mType == eStyleSVGPaintType_Server &&
 834     !EqualURIs(aPaint1.mPaint.mPaintServer, aPaint2.mPaint.mPaintServer);
 835 }
 836
 837 nsChangeHint nsStyleSVG::CalcDifference(const nsStyleSVG& aOther) const
 838 {
 839   nsChangeHint hint = nsChangeHint(0);
 840
 841   if (mTextRendering != aOther.mTextRendering) {
 842     NS_UpdateHint(hint, nsChangeHint_RepaintFrame);
 843     // May be needed for non-svg frames
 844     NS_UpdateHint(hint, nsChangeHint_ReflowFrame);
 845   }
 846
 847   if (mFill != aOther.mFill ||
 848       mStroke != aOther.mStroke) {
 849     NS_UpdateHint(hint, nsChangeHint_RepaintFrame);
 850     if (PaintURIChanged(mFill, aOther.mFill) ||
 851         PaintURIChanged(mStroke, aOther.mStroke)) {
 852       NS_UpdateHint(hint, nsChangeHint_UpdateEffects);
 853     }
 854     // Nothing more to do, below we can only set "repaint"
 855     return hint;
 856   }
 857
 858   if ( !EqualURIs(mMarkerEnd, aOther.mMarkerEnd)               ||
 859        !EqualURIs(mMarkerMid, aOther.mMarkerMid)               ||
 860        !EqualURIs(mMarkerStart, aOther.mMarkerStart)           ||
 861
 862        mStrokeDashoffset      != aOther.mStrokeDashoffset      ||
 863        mStrokeWidth           != aOther.mStrokeWidth           ||
 864
 865        mFillOpacity           != aOther.mFillOpacity           ||
 866        mStrokeMiterlimit      != aOther.mStrokeMiterlimit      ||
 867        mStrokeOpacity         != aOther.mStrokeOpacity         ||
 868
 869        mClipRule              != aOther.mClipRule              ||
 870        mColorInterpolation    != aOther.mColorInterpolation    ||
 871        mColorInterpolationFilters != aOther.mColorInterpolationFilters ||
 872        mFillRule              != aOther.mFillRule              ||
 873        mShapeRendering        != aOther.mShapeRendering        ||
 874        mStrokeDasharrayLength != aOther.mStrokeDasharrayLength ||
 875        mStrokeLinecap         != aOther.mStrokeLinecap         ||
 876        mStrokeLinejoin        != aOther.mStrokeLinejoin        ||
 877        mTextAnchor            != aOther.mTextAnchor) {
 878     NS_UpdateHint(hint, nsChangeHint_RepaintFrame);
 879     return hint;
 880   }
 881
 882   // length of stroke dasharrays are the same (tested above) - check entries
 883   for (PRUint32 i=0; i<mStrokeDasharrayLength; i++)
 884     if (mStrokeDasharray[i] != aOther.mStrokeDasharray[i]) {
 885       NS_UpdateHint(hint, nsChangeHint_RepaintFrame);
 886       return hint;
 887     }
 888
 889   return hint;
 890 }
 891
 892 #ifdef DEBUG
 893 /* static */
 894 nsChangeHint nsStyleSVG::MaxDifference()
 895 {
 896   return NS_CombineHint(NS_CombineHint(nsChangeHint_UpdateEffects,
 897                                        nsChangeHint_ReflowFrame),
 898                                        nsChangeHint_RepaintFrame);
 899 }
 900 #endif
 901
 902 // --------------------
 903 // nsStyleSVGReset
 904 //
 905 nsStyleSVGReset::nsStyleSVGReset()
 906 {
 907     mStopColor               = NS_RGB(0,0,0);
 908     mFloodColor              = NS_RGB(0,0,0);
 909     mLightingColor           = NS_RGB(255,255,255);
 910     mClipPath                = nsnull;
 911     mFilter                  = nsnull;
 912     mMask                    = nsnull;
 913     mStopOpacity             = 1.0f;
 914     mFloodOpacity            = 1.0f;
 915     mDominantBaseline        = NS_STYLE_DOMINANT_BASELINE_AUTO;
 916 }
 917
 918 nsStyleSVGReset::~nsStyleSVGReset()
 919 {
 920 }
 921
 922 nsStyleSVGReset::nsStyleSVGReset(const nsStyleSVGReset& aSource)
 923 {
 924   mStopColor = aSource.mStopColor;
 925   mFloodColor = aSource.mFloodColor;
 926   mLightingColor = aSource.mLightingColor;
 927   mClipPath = aSource.mClipPath;
 928   mFilter = aSource.mFilter;
 929   mMask = aSource.mMask;
 930   mStopOpacity = aSource.mStopOpacity;
 931   mFloodOpacity = aSource.mFloodOpacity;
 932   mDominantBaseline = aSource.mDominantBaseline;
 933 }
 934
 935 nsChangeHint nsStyleSVGReset::CalcDifference(const nsStyleSVGReset& aOther) const
 936 {
 937   nsChangeHint hint = nsChangeHint(0);
 938
 939   if (!EqualURIs(mClipPath, aOther.mClipPath) ||
 940       !EqualURIs(mFilter, aOther.mFilter)     ||
 941       !EqualURIs(mMask, aOther.mMask)) {
 942     NS_UpdateHint(hint, nsChangeHint_UpdateEffects);
 943     NS_UpdateHint(hint, nsChangeHint_ReflowFrame);
 944     NS_UpdateHint(hint, nsChangeHint_RepaintFrame);
 945   } else if (mStopColor        != aOther.mStopColor     ||
 946              mFloodColor       != aOther.mFloodColor    ||
 947              mLightingColor    != aOther.mLightingColor ||
 948              mStopOpacity      != aOther.mStopOpacity   ||
 949              mFloodOpacity     != aOther.mFloodOpacity  ||
 950              mDominantBaseline != aOther.mDominantBaseline)
 951     NS_UpdateHint(hint, nsChangeHint_RepaintFrame);
 952
 953   return hint;
 954 }
 955
 956 #ifdef DEBUG
 957 /* static */
 958 nsChangeHint nsStyleSVGReset::MaxDifference()
 959 {
 960   return NS_CombineHint(NS_CombineHint(nsChangeHint_UpdateEffects,
 961                                        nsChangeHint_ReflowFrame),
 962                                        nsChangeHint_RepaintFrame);
 963 }
 964 #endif
 965
 966 // nsStyleSVGPaint implementation
 967 nsStyleSVGPaint::~nsStyleSVGPaint()
 968 {
 969   if (mType == eStyleSVGPaintType_Server) {
 970     NS_IF_RELEASE(mPaint.mPaintServer);
 971   }
 972 }
 973
 974 void
 975 nsStyleSVGPaint::SetType(nsStyleSVGPaintType aType)
 976 {
 977   if (mType == eStyleSVGPaintType_Server) {
 978     this->~nsStyleSVGPaint();
 979     new (this) nsStyleSVGPaint();
 980   }
 981   mType = aType;
 982 }
 983
 984 nsStyleSVGPaint& nsStyleSVGPaint::operator=(const nsStyleSVGPaint& aOther)
 985 {
 986   if (this == &aOther)
 987     return *this;
 988
 989   SetType(aOther.mType);
 990
 991   mFallbackColor = aOther.mFallbackColor;
 992   if (mType == eStyleSVGPaintType_Server) {
 993     mPaint.mPaintServer = aOther.mPaint.mPaintServer;
 994     NS_IF_ADDREF(mPaint.mPaintServer);
 995   } else {
 996     mPaint.mColor = aOther.mPaint.mColor;
 997   }
 998   return *this;
 999 }
1000
1001 PRBool nsStyleSVGPaint::operator==(const nsStyleSVGPaint& aOther) const
1002 {
1003   if (mType != aOther.mType)
1004     return PR_FALSE;
1005   if (mType == eStyleSVGPaintType_Server)
1006     return EqualURIs(mPaint.mPaintServer, aOther.mPaint.mPaintServer) &&
1007            mFallbackColor == aOther.mFallbackColor;
1008   if (mType == eStyleSVGPaintType_None)
1009     return PR_TRUE;
1010   return mPaint.mColor == aOther.mPaint.mColor;
1011 }
1012
1013 #endif // MOZ_SVG
1014
1015
1016 // --------------------
1017 // nsStylePosition
1018 //
1019 nsStylePosition::nsStylePosition(void)
1020 {
1021   // positioning values not inherited
1022   nsStyleCoord  autoCoord(eStyleUnit_Auto);
1023   mOffset.SetLeft(autoCoord);
1024   mOffset.SetTop(autoCoord);
1025   mOffset.SetRight(autoCoord);
1026   mOffset.SetBottom(autoCoord);
1027   mWidth.SetAutoValue();
1028   mMinWidth.SetCoordValue(0);
1029   mMaxWidth.SetNoneValue();
1030   mHeight.SetAutoValue();
1031   mMinHeight.SetCoordValue(0);
1032   mMaxHeight.SetNoneValue();
1033   mBoxSizing = NS_STYLE_BOX_SIZING_CONTENT;
1034   mZIndex.SetAutoValue();
1035 }
1036
1037 nsStylePosition::~nsStylePosition(void)
1038 {
1039 }
1040
1041 nsStylePosition::nsStylePosition(const nsStylePosition& aSource)
1042 {
1043   memcpy((nsStylePosition*)this, &aSource, sizeof(nsStylePosition));
1044 }
1045
1046 nsChangeHint nsStylePosition::CalcDifference(const nsStylePosition& aOther) const
1047 {
1048   if (mZIndex != aOther.mZIndex) {
1049     return NS_STYLE_HINT_REFLOW;
1050   }
1051
1052   if ((mOffset == aOther.mOffset) &&
1053       (mWidth == aOther.mWidth) &&
1054       (mMinWidth == aOther.mMinWidth) &&
1055       (mMaxWidth == aOther.mMaxWidth) &&
1056       (mHeight == aOther.mHeight) &&
1057       (mMinHeight == aOther.mMinHeight) &&
1058       (mMaxHeight == aOther.mMaxHeight) &&
1059       (mBoxSizing == aOther.mBoxSizing))
1060     return NS_STYLE_HINT_NONE;
1061
1062   return nsChangeHint_ReflowFrame;
1063 }
1064
1065 #ifdef DEBUG
1066 /* static */
1067 nsChangeHint nsStylePosition::MaxDifference()
1068 {
1069   return NS_STYLE_HINT_REFLOW;
1070 }
1071 #endif
1072
1073 // --------------------
1074 // nsStyleTable
1075 //
1076
1077 nsStyleTable::nsStyleTable()
1078 {
1079   // values not inherited
1080   mLayoutStrategy = NS_STYLE_TABLE_LAYOUT_AUTO;
1081   mCols  = NS_STYLE_TABLE_COLS_NONE;
1082   mFrame = NS_STYLE_TABLE_FRAME_NONE;
1083   mRules = NS_STYLE_TABLE_RULES_NONE;
1084   mSpan = 1;
1085 }
1086
1087 nsStyleTable::~nsStyleTable(void)
1088 {
1089 }
1090
1091 nsStyleTable::nsStyleTable(const nsStyleTable& aSource)
1092 {
1093   memcpy((nsStyleTable*)this, &aSource, sizeof(nsStyleTable));
1094 }
1095
1096 nsChangeHint nsStyleTable::CalcDifference(const nsStyleTable& aOther) const
1097 {
1098   // Changes in mRules may require reframing (if border-collapse stuff changes, for example).
1099   if (mRules != aOther.mRules || mSpan != aOther.mSpan ||
1100       mLayoutStrategy != aOther.mLayoutStrategy)
1101     return NS_STYLE_HINT_FRAMECHANGE;
1102   if (mFrame != aOther.mFrame || mCols != aOther.mCols)
1103     return NS_STYLE_HINT_REFLOW;
1104   return NS_STYLE_HINT_NONE;
1105 }
1106
1107 #ifdef DEBUG
1108 /* static */
1109 nsChangeHint nsStyleTable::MaxDifference()
1110 {
1111   return NS_STYLE_HINT_FRAMECHANGE;
1112 }
1113 #endif
1114
1115 // -----------------------
1116 // nsStyleTableBorder
1117
1118 nsStyleTableBorder::nsStyleTableBorder(nsPresContext* aPresContext)
1119 {
1120   mBorderCollapse = NS_STYLE_BORDER_SEPARATE;
1121
1122   nsCompatibility compatMode = eCompatibility_FullStandards;
1123   if (aPresContext)
1124     compatMode = aPresContext->CompatibilityMode();
1125   mEmptyCells = (compatMode == eCompatibility_NavQuirks)
1126                   ? NS_STYLE_TABLE_EMPTY_CELLS_SHOW_BACKGROUND
1127                   : NS_STYLE_TABLE_EMPTY_CELLS_SHOW;
1128   mCaptionSide = NS_STYLE_CAPTION_SIDE_TOP;
1129   mBorderSpacingX = 0;
1130   mBorderSpacingY = 0;
1131 }
1132
1133 nsStyleTableBorder::~nsStyleTableBorder(void)
1134 {
1135 }
1136
1137 nsStyleTableBorder::nsStyleTableBorder(const nsStyleTableBorder& aSource)
1138 {
1139   memcpy((nsStyleTableBorder*)this, &aSource, sizeof(nsStyleTableBorder));
1140 }
1141
1142 nsChangeHint nsStyleTableBorder::CalcDifference(const nsStyleTableBorder& aOther) const
1143 {
1144   // Border-collapse changes need a reframe, because we use a different frame
1145   // class for table cells in the collapsed border model.  This is used to
1146   // conserve memory when using the separated border model (collapsed borders
1147   // require extra state to be stored).
1148   if (mBorderCollapse != aOther.mBorderCollapse) {
1149     return NS_STYLE_HINT_FRAMECHANGE;
1150   }
1151
1152   if ((mCaptionSide == aOther.mCaptionSide) &&
1153       (mBorderSpacingX == aOther.mBorderSpacingX) &&
1154       (mBorderSpacingY == aOther.mBorderSpacingY)) {
1155     if (mEmptyCells == aOther.mEmptyCells)
1156       return NS_STYLE_HINT_NONE;
1157     return NS_STYLE_HINT_VISUAL;
1158   }
1159   else
1160     return NS_STYLE_HINT_REFLOW;
1161 }
1162
1163 #ifdef DEBUG
1164 /* static */
1165 nsChangeHint nsStyleTableBorder::MaxDifference()
1166 {
1167   return NS_STYLE_HINT_FRAMECHANGE;
1168 }
1169 #endif
1170
1171 // --------------------
1172 // nsStyleColor
1173 //
1174
1175 nsStyleColor::nsStyleColor(nsPresContext* aPresContext)
1176 {
1177   mColor = aPresContext->DefaultColor();
1178 }
1179
1180 nsStyleColor::nsStyleColor(const nsStyleColor& aSource)
1181 {
1182   mColor = aSource.mColor;
1183 }
1184
1185 nsChangeHint nsStyleColor::CalcDifference(const nsStyleColor& aOther) const
1186 {
1187   if (mColor == aOther.mColor)
1188     return NS_STYLE_HINT_NONE;
1189   return NS_STYLE_HINT_VISUAL;
1190 }
1191
1192 #ifdef DEBUG
1193 /* static */
1194 nsChangeHint nsStyleColor::MaxDifference()
1195 {
1196   return NS_STYLE_HINT_VISUAL;
1197 }
1198 #endif
1199
1200 // --------------------
1201 // nsStyleBackground
1202 //
1203
1204 nsStyleBackground::nsStyleBackground()
1205   : mBackgroundFlags(NS_STYLE_BG_IMAGE_NONE),
1206     mBackgroundAttachment(NS_STYLE_BG_ATTACHMENT_SCROLL),
1207     mBackgroundClip(NS_STYLE_BG_CLIP_BORDER),
1208     mBackgroundInlinePolicy(NS_STYLE_BG_INLINE_POLICY_CONTINUOUS),
1209     mBackgroundOrigin(NS_STYLE_BG_ORIGIN_PADDING),
1210     mBackgroundRepeat(NS_STYLE_BG_REPEAT_XY),
1211     mBackgroundColor(NS_RGBA(0, 0, 0, 0))
1212 {
1213 }
1214
1215 nsStyleBackground::nsStyleBackground(const nsStyleBackground& aSource)
1216   : mBackgroundFlags(aSource.mBackgroundFlags),
1217     mBackgroundAttachment(aSource.mBackgroundAttachment),
1218     mBackgroundClip(aSource.mBackgroundClip),
1219     mBackgroundInlinePolicy(aSource.mBackgroundInlinePolicy),
1220     mBackgroundOrigin(aSource.mBackgroundOrigin),
1221     mBackgroundRepeat(aSource.mBackgroundRepeat),
1222     mBackgroundXPosition(aSource.mBackgroundXPosition),
1223     mBackgroundYPosition(aSource.mBackgroundYPosition),
1224     mBackgroundColor(aSource.mBackgroundColor),
1225     mBackgroundImage(aSource.mBackgroundImage)
1226 {
1227 }
1228
1229 nsStyleBackground::~nsStyleBackground()
1230 {
1231 }
1232
1233 nsChangeHint nsStyleBackground::CalcDifference(const nsStyleBackground& aOther) const
1234 {
1235   if ((mBackgroundAttachment == aOther.mBackgroundAttachment) &&
1236       (mBackgroundFlags == aOther.mBackgroundFlags) &&
1237       (mBackgroundRepeat == aOther.mBackgroundRepeat) &&
1238       (mBackgroundColor == aOther.mBackgroundColor) &&
1239       (mBackgroundClip == aOther.mBackgroundClip) &&
1240       (mBackgroundInlinePolicy == aOther.mBackgroundInlinePolicy) &&
1241       (mBackgroundOrigin == aOther.mBackgroundOrigin) &&
1242       EqualImages(mBackgroundImage, aOther.mBackgroundImage) &&
1243       ((!(mBackgroundFlags & NS_STYLE_BG_X_POSITION_PERCENT) ||
1244        (mBackgroundXPosition.mFloat == aOther.mBackgroundXPosition.mFloat)) &&
1245        (!(mBackgroundFlags & NS_STYLE_BG_X_POSITION_LENGTH) ||
1246         (mBackgroundXPosition.mCoord == aOther.mBackgroundXPosition.mCoord))) &&
1247       ((!(mBackgroundFlags & NS_STYLE_BG_Y_POSITION_PERCENT) ||
1248        (mBackgroundYPosition.mFloat == aOther.mBackgroundYPosition.mFloat)) &&
1249        (!(mBackgroundFlags & NS_STYLE_BG_Y_POSITION_LENGTH) ||
1250         (mBackgroundYPosition.mCoord == aOther.mBackgroundYPosition.mCoord))))
1251     return NS_STYLE_HINT_NONE;
1252   return NS_STYLE_HINT_VISUAL;
1253 }
1254
1255 #ifdef DEBUG
1256 /* static */
1257 nsChangeHint nsStyleBackground::MaxDifference()
1258 {
1259   return NS_STYLE_HINT_VISUAL;
1260 }
1261 #endif
1262
1263 PRBool nsStyleBackground::HasFixedBackground() const
1264 {
1265   return mBackgroundAttachment == NS_STYLE_BG_ATTACHMENT_FIXED &&
1266          mBackgroundImage;
1267 }
1268
1269 // --------------------
1270 // nsStyleDisplay
1271 //
1272
1273 nsStyleDisplay::nsStyleDisplay()
1274 {
1275   mAppearance = NS_THEME_NONE;
1276   mDisplay = NS_STYLE_DISPLAY_INLINE;
1277   mOriginalDisplay = NS_STYLE_DISPLAY_NONE;
1278   mPosition = NS_STYLE_POSITION_STATIC;
1279   mFloats = NS_STYLE_FLOAT_NONE;
1280   mBreakType = NS_STYLE_CLEAR_NONE;
1281   mBreakBefore = PR_FALSE;
1282   mBreakAfter = PR_FALSE;
1283   mOverflowX = NS_STYLE_OVERFLOW_VISIBLE;
1284   mOverflowY = NS_STYLE_OVERFLOW_VISIBLE;
1285   mClipFlags = NS_STYLE_CLIP_AUTO;
1286   mClip.SetRect(0,0,0,0);
1287   mOpacity = 1.0f;
1288   mTransformPresent = PR_FALSE; // No transform
1289   mTransformOrigin[0].SetPercentValue(0.5f); // Transform is centered on origin
1290   mTransformOrigin[1].SetPercentValue(0.5f);
1291 }
1292
1293 nsStyleDisplay::nsStyleDisplay(const nsStyleDisplay& aSource)
1294 {
1295   mAppearance = aSource.mAppearance;
1296   mDisplay = aSource.mDisplay;
1297   mOriginalDisplay = aSource.mOriginalDisplay;
1298   mBinding = aSource.mBinding;
1299   mPosition = aSource.mPosition;
1300   mFloats = aSource.mFloats;
1301   mBreakType = aSource.mBreakType;
1302   mBreakBefore = aSource.mBreakBefore;
1303   mBreakAfter = aSource.mBreakAfter;
1304   mOverflowX = aSource.mOverflowX;
1305   mOverflowY = aSource.mOverflowY;
1306   mClipFlags = aSource.mClipFlags;
1307   mClip = aSource.mClip;
1308   mOpacity = aSource.mOpacity;
1309
1310   /* Copy over the transformation information. */
1311   mTransformPresent = aSource.mTransformPresent;
1312   if (mTransformPresent)
1313     mTransform = aSource.mTransform;
1314
1315   /* Copy over transform origin. */
1316   mTransformOrigin[0] = aSource.mTransformOrigin[0];
1317   mTransformOrigin[1] = aSource.mTransformOrigin[1];
1318 }
1319
1320 nsChangeHint nsStyleDisplay::CalcDifference(const nsStyleDisplay& aOther) const
1321 {
1322   nsChangeHint hint = nsChangeHint(0);
1323
1324   if (!EqualURIs(mBinding, aOther.mBinding)
1325       || mPosition != aOther.mPosition
1326       || mDisplay != aOther.mDisplay
1327       || (mFloats == NS_STYLE_FLOAT_NONE) != (aOther.mFloats == NS_STYLE_FLOAT_NONE)
1328       || mOverflowX != aOther.mOverflowX
1329       || mOverflowY != aOther.mOverflowY)
1330     NS_UpdateHint(hint, nsChangeHint_ReconstructFrame);
1331
1332   if (mFloats != aOther.mFloats)
1333     NS_UpdateHint(hint, nsChangeHint_ReflowFrame);
1334
1335   if (mClipFlags != aOther.mClipFlags || mClip != aOther.mClip) {
1336     NS_UpdateHint(hint, nsChangeHint_ReflowFrame);
1337   }
1338   // XXX the following is conservative, for now: changing float breaking shouldn't
1339   // necessarily require a repaint, reflow should suffice.
1340   if (mBreakType != aOther.mBreakType
1341       || mBreakBefore != aOther.mBreakBefore
1342       || mBreakAfter != aOther.mBreakAfter
1343       || mAppearance != aOther.mAppearance)
1344     NS_UpdateHint(hint, NS_CombineHint(nsChangeHint_ReflowFrame, nsChangeHint_RepaintFrame));
1345
1346   if (mOpacity != aOther.mOpacity)
1347     NS_UpdateHint(hint, nsChangeHint_RepaintFrame);
1348
1349   /* If we've added or removed the transform property, we need to reconstruct the frame to add
1350    * or remove the view object, and also to handle abs-pos and fixed-pos containers.
1351    */
1352   if (mTransformPresent != aOther.mTransformPresent) {
1353     NS_UpdateHint(hint, nsChangeHint_ReconstructFrame);
1354   }
1355   else if (mTransformPresent) {
1356     /* Otherwise, if we've kept the property lying around and we already had a
1357      * transform, we need to see whether or not we've changed the transform.
1358      * If so, we need to do a reflow and a repaint. The reflow is to recompute
1359      * the overflow rect (which probably changed if the transform changed)
1360      * and to redraw within the bounds of that new overflow rect.
1361      */
1362     if (mTransform != aOther.mTransform)
1363       NS_UpdateHint(hint, NS_CombineHint(nsChangeHint_ReflowFrame,
1364                                          nsChangeHint_RepaintFrame));
1365
1366     for (PRUint8 index = 0; index < 2; ++index)
1367       if (mTransformOrigin[index] != aOther.mTransformOrigin[index]) {
1368         NS_UpdateHint(hint, NS_CombineHint(nsChangeHint_ReflowFrame,
1369                                            nsChangeHint_RepaintFrame));
1370         break;
1371       }
1372   }
1373
1374
1375   return hint;
1376 }
1377
1378 #ifdef DEBUG
1379 /* static */
1380 nsChangeHint nsStyleDisplay::MaxDifference()
1381 {
1382   // All the parts of FRAMECHANGE are present above in CalcDifference.
1383   return NS_STYLE_HINT_FRAMECHANGE;
1384 }
1385 #endif
1386
1387 // --------------------
1388 // nsStyleVisibility
1389 //
1390
1391 nsStyleVisibility::nsStyleVisibility(nsPresContext* aPresContext)
1392 {
1393   PRUint32 bidiOptions = aPresContext->GetBidi();
1394   if (GET_BIDI_OPTION_DIRECTION(bidiOptions) == IBMBIDI_TEXTDIRECTION_RTL)
1395     mDirection = NS_STYLE_DIRECTION_RTL;
1396   else
1397     mDirection = NS_STYLE_DIRECTION_LTR;
1398
1399   mLangGroup = aPresContext->GetLangGroup();
1400   mVisible = NS_STYLE_VISIBILITY_VISIBLE;
1401 }
1402
1403 nsStyleVisibility::nsStyleVisibility(const nsStyleVisibility& aSource)
1404 {
1405   mDirection = aSource.mDirection;
1406   mVisible = aSource.mVisible;
1407   mLangGroup = aSource.mLangGroup;
1408 }
1409
1410 nsChangeHint nsStyleVisibility::CalcDifference(const nsStyleVisibility& aOther) const
1411 {
1412   if ((mDirection == aOther.mDirection) &&
1413       (mLangGroup == aOther.mLangGroup)) {
1414     if ((mVisible == aOther.mVisible)) {
1415       return NS_STYLE_HINT_NONE;
1416     }
1417     if ((NS_STYLE_VISIBILITY_COLLAPSE == mVisible) ||
1418         (NS_STYLE_VISIBILITY_COLLAPSE == aOther.mVisible)) {
1419       return NS_STYLE_HINT_REFLOW;
1420     }
1421     return NS_STYLE_HINT_VISUAL;
1422   }
1423   return NS_STYLE_HINT_REFLOW;
1424 }
1425
1426 #ifdef DEBUG
1427 /* static */
1428 nsChangeHint nsStyleVisibility::MaxDifference()
1429 {
1430   return NS_STYLE_HINT_REFLOW;
1431 }
1432 #endif
1433
1434 nsStyleContentData::~nsStyleContentData()
1435 {
1436   if (mType == eStyleContentType_Image) {
1437     NS_IF_RELEASE(mContent.mImage);
1438   } else if (mType == eStyleContentType_Counter ||
1439              mType == eStyleContentType_Counters) {
1440     mContent.mCounters->Release();
1441   } else if (mContent.mString) {
1442     NS_Free(mContent.mString);
1443   }
1444 }
1445
1446 nsStyleContentData& nsStyleContentData::operator=(const nsStyleContentData& aOther)
1447 {
1448   if (this == &aOther)
1449     return *this;
1450   this->~nsStyleContentData();
1451   new (this) nsStyleContentData();
1452
1453   mType = aOther.mType;
1454   if (mType == eStyleContentType_Image) {
1455     mContent.mImage = aOther.mContent.mImage;
1456     NS_IF_ADDREF(mContent.mImage);
1457   } else if (mType == eStyleContentType_Counter ||
1458              mType == eStyleContentType_Counters) {
1459     mContent.mCounters = aOther.mContent.mCounters;
1460     mContent.mCounters->AddRef();
1461   } else if (aOther.mContent.mString) {
1462     mContent.mString = NS_strdup(aOther.mContent.mString);
1463   } else {
1464     mContent.mString = nsnull;
1465   }
1466   return *this;
1467 }
1468
1469 PRBool nsStyleContentData::operator==(const nsStyleContentData& aOther) const
1470 {
1471   if (mType != aOther.mType)
1472     return PR_FALSE;
1473   if (mType == eStyleContentType_Image) {
1474     if (!mContent.mImage || !aOther.mContent.mImage)
1475       return mContent.mImage == aOther.mContent.mImage;
1476     PRBool eq;
1477     nsCOMPtr<nsIURI> thisURI, otherURI;
1478     mContent.mImage->GetURI(getter_AddRefs(thisURI));
1479     aOther.mContent.mImage->GetURI(getter_AddRefs(otherURI));
1480     return thisURI == otherURI ||  // handles null==null
1481            (thisURI && otherURI &&
1482             NS_SUCCEEDED(thisURI->Equals(otherURI, &eq)) &&
1483             eq);
1484   }
1485   if (mType == eStyleContentType_Counter ||
1486       mType == eStyleContentType_Counters)
1487     return *mContent.mCounters == *aOther.mContent.mCounters;
1488   return nsCRT::strcmp(mContent.mString, aOther.mContent.mString) == 0;
1489 }
1490
1491 //-----------------------
1492 // nsStyleContent
1493 //
1494
1495 nsStyleContent::nsStyleContent(void)
1496   : mMarkerOffset(),
1497     mContentCount(0),
1498     mContents(nsnull),
1499     mIncrementCount(0),
1500     mIncrements(nsnull),
1501     mResetCount(0),
1502     mResets(nsnull)
1503 {
1504   mMarkerOffset.SetAutoValue();
1505 }
1506
1507 nsStyleContent::~nsStyleContent(void)
1508 {
1509   DELETE_ARRAY_IF(mContents);
1510   DELETE_ARRAY_IF(mIncrements);
1511   DELETE_ARRAY_IF(mResets);
1512 }
1513
1514 nsStyleContent::nsStyleContent(const nsStyleContent& aSource)
1515    :mMarkerOffset(),
1516     mContentCount(0),
1517     mContents(nsnull),
1518     mIncrementCount(0),
1519     mIncrements(nsnull),
1520     mResetCount(0),
1521     mResets(nsnull)
1522
1523 {
1524   mMarkerOffset = aSource.mMarkerOffset;
1525
1526   PRUint32 index;
1527   if (NS_SUCCEEDED(AllocateContents(aSource.ContentCount()))) {
1528     for (index = 0; index < mContentCount; index++) {
1529       ContentAt(index) = aSource.ContentAt(index);
1530     }
1531   }
1532
1533   if (NS_SUCCEEDED(AllocateCounterIncrements(aSource.CounterIncrementCount()))) {
1534     for (index = 0; index < mIncrementCount; index++) {
1535       const nsStyleCounterData *data = aSource.GetCounterIncrementAt(index);
1536       mIncrements[index].mCounter = data->mCounter;
1537       mIncrements[index].mValue = data->mValue;
1538     }
1539   }
1540
1541   if (NS_SUCCEEDED(AllocateCounterResets(aSource.CounterResetCount()))) {
1542     for (index = 0; index < mResetCount; index++) {
1543       const nsStyleCounterData *data = aSource.GetCounterResetAt(index);
1544       mResets[index].mCounter = data->mCounter;
1545       mResets[index].mValue = data->mValue;
1546     }
1547   }
1548 }
1549
1550 nsChangeHint nsStyleContent::CalcDifference(const nsStyleContent& aOther) const
1551 {
1552   if (mContentCount != aOther.mContentCount ||
1553       mIncrementCount != aOther.mIncrementCount ||
1554       mResetCount != aOther.mResetCount) {
1555     return NS_STYLE_HINT_FRAMECHANGE;
1556   }
1557
1558   PRUint32 ix = mContentCount;
1559   while (0 < ix--) {
1560     if (mContents[ix] != aOther.mContents[ix]) {
1561       // Unfortunately we need to reframe here; a simple reflow
1562       // will not pick up different text or different image URLs,
1563       // since we set all that up in the CSSFrameConstructor
1564       return NS_STYLE_HINT_FRAMECHANGE;
1565     }
1566   }
1567   ix = mIncrementCount;
1568   while (0 < ix--) {
1569     if ((mIncrements[ix].mValue != aOther.mIncrements[ix].mValue) ||
1570         (mIncrements[ix].mCounter != aOther.mIncrements[ix].mCounter)) {
1571       return NS_STYLE_HINT_FRAMECHANGE;
1572     }
1573   }
1574   ix = mResetCount;
1575   while (0 < ix--) {
1576     if ((mResets[ix].mValue != aOther.mResets[ix].mValue) ||
1577         (mResets[ix].mCounter != aOther.mResets[ix].mCounter)) {
1578       return NS_STYLE_HINT_FRAMECHANGE;
1579     }
1580   }
1581   if (mMarkerOffset != aOther.mMarkerOffset) {
1582     return NS_STYLE_HINT_REFLOW;
1583   }
1584   return NS_STYLE_HINT_NONE;
1585 }
1586
1587 #ifdef DEBUG
1588 /* static */
1589 nsChangeHint nsStyleContent::MaxDifference()
1590 {
1591   return NS_STYLE_HINT_FRAMECHANGE;
1592 }
1593 #endif
1594
1595 nsresult nsStyleContent::AllocateContents(PRUint32 aCount)
1596 {
1597   // We need to run the destructors of the elements of mContents, so we
1598   // delete and reallocate even if aCount == mContentCount.  (If
1599   // nsStyleContentData had its members private and managed their
1600   // ownership on setting, we wouldn't need this, but that seems
1601   // unnecessary at this point.)
1602   DELETE_ARRAY_IF(mContents);
1603   if (aCount) {
1604     mContents = new nsStyleContentData[aCount];
1605     if (! mContents) {
1606       mContentCount = 0;
1607       return NS_ERROR_OUT_OF_MEMORY;
1608     }
1609   }
1610   mContentCount = aCount;
1611   return NS_OK;
1612 }
1613
1614 // ---------------------
1615 // nsStyleQuotes
1616 //
1617
1618 nsStyleQuotes::nsStyleQuotes(void)
1619   : mQuotesCount(0),
1620     mQuotes(nsnull)
1621 {
1622   SetInitial();
1623 }
1624
1625 nsStyleQuotes::~nsStyleQuotes(void)
1626 {
1627   DELETE_ARRAY_IF(mQuotes);
1628 }
1629
1630 nsStyleQuotes::nsStyleQuotes(const nsStyleQuotes& aSource)
1631   : mQuotesCount(0),
1632     mQuotes(nsnull)
1633 {
1634   CopyFrom(aSource);
1635 }
1636
1637 void
1638 nsStyleQuotes::SetInitial()
1639 {
1640   // The initial value for quotes is the en-US typographic convention:
1641   // outermost are LEFT and RIGHT DOUBLE QUOTATION MARK, alternating
1642   // with LEFT and RIGHT SINGLE QUOTATION MARK.
1643   static const PRUnichar initialQuotes[8] = {
1644     0x201C, 0, 0x201D, 0, 0x2018, 0, 0x2019, 0
1645   };
1646
1647   if (NS_SUCCEEDED(AllocateQuotes(2))) {
1648     SetQuotesAt(0,
1649                 nsDependentString(&initialQuotes[0], 1),
1650                 nsDependentString(&initialQuotes[2], 1));
1651     SetQuotesAt(1,
1652                 nsDependentString(&initialQuotes[4], 1),
1653                 nsDependentString(&initialQuotes[6], 1));
1654   }
1655 }
1656
1657 void
1658 nsStyleQuotes::CopyFrom(const nsStyleQuotes& aSource)
1659 {
1660   if (NS_SUCCEEDED(AllocateQuotes(aSource.QuotesCount()))) {
1661     PRUint32 count = (mQuotesCount * 2);
1662     for (PRUint32 index = 0; index < count; index += 2) {
1663       aSource.GetQuotesAt(index, mQuotes[index], mQuotes[index + 1]);
1664     }
1665   }
1666 }
1667
1668 nsChangeHint nsStyleQuotes::CalcDifference(const nsStyleQuotes& aOther) const
1669 {
1670   // If the quotes implementation is ever going to change we might not need
1671   // a framechange here and a reflow should be sufficient.  See bug 35768.
1672   if (mQuotesCount == aOther.mQuotesCount) {
1673     PRUint32 ix = (mQuotesCount * 2);
1674     while (0 < ix--) {
1675       if (mQuotes[ix] != aOther.mQuotes[ix]) {
1676         return NS_STYLE_HINT_FRAMECHANGE;
1677       }
1678     }
1679
1680     return NS_STYLE_HINT_NONE;
1681   }
1682   return NS_STYLE_HINT_FRAMECHANGE;
1683 }
1684
1685 #ifdef DEBUG
1686 /* static */
1687 nsChangeHint nsStyleQuotes::MaxDifference()
1688 {
1689   return NS_STYLE_HINT_FRAMECHANGE;
1690 }
1691 #endif
1692
1693 // --------------------
1694 // nsStyleTextReset
1695 //
1696
1697 nsStyleTextReset::nsStyleTextReset(void)
1698 {
1699   mVerticalAlign.SetIntValue(NS_STYLE_VERTICAL_ALIGN_BASELINE, eStyleUnit_Enumerated);
1700   mTextDecoration = NS_STYLE_TEXT_DECORATION_NONE;
1701   mUnicodeBidi = NS_STYLE_UNICODE_BIDI_NORMAL;
1702 }
1703
1704 nsStyleTextReset::nsStyleTextReset(const nsStyleTextReset& aSource)
1705 {
1706   memcpy((nsStyleTextReset*)this, &aSource, sizeof(nsStyleTextReset));
1707 }
1708
1709 nsStyleTextReset::~nsStyleTextReset(void) { }
1710
1711 nsChangeHint nsStyleTextReset::CalcDifference(const nsStyleTextReset& aOther) const
1712 {
1713   if (mVerticalAlign == aOther.mVerticalAlign
1714       && mUnicodeBidi == aOther.mUnicodeBidi) {
1715     if (mTextDecoration != aOther.mTextDecoration) {
1716       // Reflow for blink changes, repaint for others
1717       return
1718         (mTextDecoration & NS_STYLE_TEXT_DECORATION_BLINK) ==
1719         (aOther.mTextDecoration & NS_STYLE_TEXT_DECORATION_BLINK) ?
1720           NS_STYLE_HINT_VISUAL : NS_STYLE_HINT_REFLOW;
1721     }
1722
1723     return NS_STYLE_HINT_NONE;
1724   }
1725   return NS_STYLE_HINT_REFLOW;
1726 }
1727
1728 #ifdef DEBUG
1729 /* static */
1730 nsChangeHint nsStyleTextReset::MaxDifference()
1731 {
1732   return NS_STYLE_HINT_REFLOW;
1733 }
1734 #endif
1735
1736 // --------------------
1737 // nsCSSShadowArray
1738 // nsCSSShadowItem
1739 //
1740
1741 nsrefcnt
1742 nsCSSShadowArray::Release()
1743 {
1744   mRefCnt--;
1745   if (mRefCnt == 0) {
1746     delete this;
1747     return 0;
1748   }
1749   return mRefCnt;
1750 }
1751
1752 // Allowed to return one of NS_STYLE_HINT_NONE, NS_STYLE_HINT_REFLOW
1753 // or NS_STYLE_HINT_VISUAL. Currently we just return NONE or REFLOW, though.
1754 static nsChangeHint
1755 CalcShadowDifference(nsCSSShadowArray* lhs,
1756                      nsCSSShadowArray* rhs)
1757 {
1758   if (lhs == rhs)
1759     return NS_STYLE_HINT_NONE;
1760
1761   if (!lhs || !rhs || lhs->Length() != rhs->Length())
1762     return NS_STYLE_HINT_REFLOW;
1763
1764   for (PRUint32 i = 0; i < lhs->Length(); ++i) {
1765     if (*lhs->ShadowAt(i) != *rhs->ShadowAt(i))
1766       return NS_STYLE_HINT_REFLOW;
1767   }
1768   return NS_STYLE_HINT_NONE;
1769 }
1770
1771 // --------------------
1772 // nsStyleText
1773 //
1774
1775 nsStyleText::nsStyleText(void)
1776 {
1777   mTextAlign = NS_STYLE_TEXT_ALIGN_DEFAULT;
1778   mTextTransform = NS_STYLE_TEXT_TRANSFORM_NONE;
1779   mWhiteSpace = NS_STYLE_WHITESPACE_NORMAL;
1780   mWordWrap = NS_STYLE_WORDWRAP_NORMAL;
1781
1782   mLetterSpacing.SetNormalValue();
1783   mLineHeight.SetNormalValue();
1784   mTextIndent.SetCoordValue(0);
1785   mWordSpacing.SetNormalValue();
1786
1787   mTextShadow = nsnull;
1788 }
1789
1790 nsStyleText::nsStyleText(const nsStyleText& aSource)
1791   : mTextAlign(aSource.mTextAlign),
1792     mTextTransform(aSource.mTextTransform),
1793     mWhiteSpace(aSource.mWhiteSpace),
1794     mWordWrap(aSource.mWordWrap),
1795     mLetterSpacing(aSource.mLetterSpacing),
1796     mLineHeight(aSource.mLineHeight),
1797     mTextIndent(aSource.mTextIndent),
1798     mWordSpacing(aSource.mWordSpacing),
1799     mTextShadow(aSource.mTextShadow)
1800 { }
1801
1802 nsStyleText::~nsStyleText(void) { }
1803
1804 nsChangeHint nsStyleText::CalcDifference(const nsStyleText& aOther) const
1805 {
1806   if ((mTextAlign != aOther.mTextAlign) ||
1807       (mTextTransform != aOther.mTextTransform) ||
1808       (mWhiteSpace != aOther.mWhiteSpace) ||
1809       (mWordWrap != aOther.mWordWrap) ||
1810       (mLetterSpacing != aOther.mLetterSpacing) ||
1811       (mLineHeight != aOther.mLineHeight) ||
1812       (mTextIndent != aOther.mTextIndent) ||
1813       (mWordSpacing != aOther.mWordSpacing))
1814     return NS_STYLE_HINT_REFLOW;
1815
1816   return CalcShadowDifference(mTextShadow, aOther.mTextShadow);
1817 }
1818
1819 #ifdef DEBUG
1820 /* static */
1821 nsChangeHint nsStyleText::MaxDifference()
1822 {
1823   return NS_STYLE_HINT_REFLOW;
1824 }
1825 #endif
1826
1827 //-----------------------
1828 // nsStyleUserInterface
1829 //
1830
1831 nsCursorImage::nsCursorImage()
1832   : mHaveHotspot(PR_FALSE)
1833   , mHotspotX(0.0f)
1834   , mHotspotY(0.0f)
1835 {
1836 }
1837
1838 nsStyleUserInterface::nsStyleUserInterface(void)
1839 {
1840   mUserInput = NS_STYLE_USER_INPUT_AUTO;
1841   mUserModify = NS_STYLE_USER_MODIFY_READ_ONLY;
1842   mUserFocus = NS_STYLE_USER_FOCUS_NONE;
1843
1844   mCursor = NS_STYLE_CURSOR_AUTO; // fix for bugzilla bug 51113
1845
1846   mCursorArrayLength = 0;
1847   mCursorArray = nsnull;
1848 }
1849
1850 nsStyleUserInterface::nsStyleUserInterface(const nsStyleUserInterface& aSource) :
1851   mUserInput(aSource.mUserInput),
1852   mUserModify(aSource.mUserModify),
1853   mUserFocus(aSource.mUserFocus),
1854   mCursor(aSource.mCursor)
1855 {
1856   CopyCursorArrayFrom(aSource);
1857 }
1858
1859 nsStyleUserInterface::~nsStyleUserInterface(void)
1860 {
1861   delete [] mCursorArray;
1862 }
1863
1864 nsChangeHint nsStyleUserInterface::CalcDifference(const nsStyleUserInterface& aOther) const
1865 {
1866   nsChangeHint hint = nsChangeHint(0);
1867   if (mCursor != aOther.mCursor)
1868     NS_UpdateHint(hint, nsChangeHint_UpdateCursor);
1869
1870   // We could do better. But it wouldn't be worth it, URL-specified cursors are
1871   // rare.
1872   if (mCursorArrayLength > 0 || aOther.mCursorArrayLength > 0)
1873     NS_UpdateHint(hint, nsChangeHint_UpdateCursor);
1874
1875   if (mUserModify != aOther.mUserModify)
1876     NS_UpdateHint(hint, NS_STYLE_HINT_VISUAL);
1877
1878   if ((mUserInput != aOther.mUserInput) &&
1879       ((NS_STYLE_USER_INPUT_NONE == mUserInput) ||
1880        (NS_STYLE_USER_INPUT_NONE == aOther.mUserInput))) {
1881     NS_UpdateHint(hint, NS_STYLE_HINT_FRAMECHANGE);
1882   }
1883
1884   // ignore mUserFocus
1885
1886   return hint;
1887 }
1888
1889 #ifdef DEBUG
1890 /* static */
1891 nsChangeHint nsStyleUserInterface::MaxDifference()
1892 {
1893   return nsChangeHint(nsChangeHint_UpdateCursor | NS_STYLE_HINT_FRAMECHANGE);
1894 }
1895 #endif
1896
1897 void
1898 nsStyleUserInterface::CopyCursorArrayFrom(const nsStyleUserInterface& aSource)
1899 {
1900   mCursorArray = nsnull;
1901   mCursorArrayLength = 0;
1902   if (aSource.mCursorArrayLength) {
1903     mCursorArray = new nsCursorImage[aSource.mCursorArrayLength];
1904     if (mCursorArray) {
1905       mCursorArrayLength = aSource.mCursorArrayLength;
1906       for (PRUint32 i = 0; i < mCursorArrayLength; ++i)
1907         mCursorArray[i] = aSource.mCursorArray[i];
1908     }
1909   }
1910 }
1911
1912 //-----------------------
1913 // nsStyleUIReset
1914 //
1915
1916 nsStyleUIReset::nsStyleUIReset(void)
1917 {
1918   mUserSelect = NS_STYLE_USER_SELECT_AUTO;
1919   mForceBrokenImageIcon = 0;
1920   mIMEMode = NS_STYLE_IME_MODE_AUTO;
1921   mWindowShadow = NS_STYLE_WINDOW_SHADOW_DEFAULT;
1922 }
1923
1924 nsStyleUIReset::nsStyleUIReset(const nsStyleUIReset& aSource)
1925 {
1926   mUserSelect = aSource.mUserSelect;
1927   mForceBrokenImageIcon = aSource.mForceBrokenImageIcon;
1928   mIMEMode = aSource.mIMEMode;
1929   mWindowShadow = aSource.mWindowShadow;
1930 }
1931
1932 nsStyleUIReset::~nsStyleUIReset(void)
1933 {
1934 }
1935
1936 nsChangeHint nsStyleUIReset::CalcDifference(const nsStyleUIReset& aOther) const
1937 {
1938   // ignore mIMEMode
1939   if (mForceBrokenImageIcon != aOther.mForceBrokenImageIcon)
1940     return NS_STYLE_HINT_FRAMECHANGE;
1941   if (mWindowShadow != aOther.mWindowShadow) {
1942     // We really need just an nsChangeHint_SyncFrameView, except
1943     // on an ancestor of the frame, so we get that by doing a
1944     // reflow.
1945     return NS_STYLE_HINT_REFLOW;
1946   }
1947   if (mUserSelect != aOther.mUserSelect)
1948     return NS_STYLE_HINT_VISUAL;
1949   return NS_STYLE_HINT_NONE;
1950 }
1951
1952 #ifdef DEBUG
1953 /* static */
1954 nsChangeHint nsStyleUIReset::MaxDifference()
1955 {
1956   return NS_STYLE_HINT_FRAMECHANGE;
1957 }
1958 #endif
1959