layout/style/nsStyleCoord.h

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 /* representation of length values in computed style data */
   7
   8 #ifndef nsStyleCoord_h___
   9 #define nsStyleCoord_h___
  10
  11 #include "nsCoord.h"
  12 #include "nsStyleConsts.h"
  13
  14 enum nsStyleUnit : uint8_t {
  15   eStyleUnit_Null         = 0,      // (no value) value is not specified
  16   eStyleUnit_Normal       = 1,      // (no value)
  17   eStyleUnit_Auto         = 2,      // (no value)
  18   eStyleUnit_None         = 3,      // (no value)
  19   eStyleUnit_Percent      = 10,     // (float) 1.0 == 100%
  20   eStyleUnit_Factor       = 11,     // (float) a multiplier
  21   eStyleUnit_Degree       = 12,     // (float) angle in degrees
  22   eStyleUnit_Grad         = 13,     // (float) angle in grads
  23   eStyleUnit_Radian       = 14,     // (float) angle in radians
  24   eStyleUnit_Turn         = 15,     // (float) angle in turns
  25   eStyleUnit_FlexFraction = 16,     // (float) <flex> in fr units
  26   eStyleUnit_Coord        = 20,     // (nscoord) value is twips
  27   eStyleUnit_Integer      = 30,     // (int) value is simple integer
  28   eStyleUnit_Enumerated   = 32,     // (int) value has enumerated meaning
  29
  30   // The following are reference counted allocated types.
  31   eStyleUnit_Calc         = 40,     // (Calc*) calc() toplevel; always present
  32                                     // to distinguish 50% from calc(50%), etc.
  33
  34   eStyleUnit_MAX          = 40      // highest valid nsStyleUnit value
  35 };
  36
  37 typedef union {
  38   int32_t     mInt;   // nscoord is a int32_t for now
  39   float       mFloat;
  40   // An mPointer is a reference counted pointer.  Currently this can only
  41   // ever be an nsStyleCoord::Calc*.
  42   void*       mPointer;
  43 } nsStyleUnion;
  44
  45 /**
  46  * Class that hold a single size specification used by the style
  47  * system.  The size specification consists of two parts -- a number
  48  * and a unit.  The number is an integer, a floating point value, an
  49  * nscoord, or undefined, and the unit is an nsStyleUnit.  Checking
  50  * the unit is a must before asking for the value in any particular
  51  * form.
  52  */
  53 class nsStyleCoord {
  54 public:
  55   // Non-reference counted calc() value.  See nsStyleStruct.h for some uses
  56   // of this.
  57   struct CalcValue {
  58     // Every calc() expression evaluates to a length plus a percentage.
  59     nscoord mLength;
  60     float mPercent;
  61     bool mHasPercent; // whether there was any % syntax, even if 0
  62
  63     bool operator==(const CalcValue& aOther) const {
  64       return mLength == aOther.mLength &&
  65              mPercent == aOther.mPercent &&
  66              mHasPercent == aOther.mHasPercent;
  67     }
  68     bool operator!=(const CalcValue& aOther) const {
  69       return !(*this == aOther);
  70     }
  71   };
  72
  73   // Reference counted calc() value.  This is the type that is used to store
  74   // the calc() value in nsStyleCoord.
  75   struct Calc MOZ_FINAL : public CalcValue {
  76     NS_INLINE_DECL_REFCOUNTING(Calc)
  77     Calc() {}
  78
  79   private:
  80     Calc(const Calc&) = delete;
  81     ~Calc() {}
  82     Calc& operator=(const Calc&) = delete;
  83   };
  84
  85   explicit nsStyleCoord(nsStyleUnit aUnit = eStyleUnit_Null);
  86   enum CoordConstructorType { CoordConstructor };
  87   inline nsStyleCoord(nscoord aValue, CoordConstructorType);
  88   nsStyleCoord(int32_t aValue, nsStyleUnit aUnit);
  89   nsStyleCoord(float aValue, nsStyleUnit aUnit);
  90   inline nsStyleCoord(const nsStyleCoord& aCopy);
  91   inline nsStyleCoord(const nsStyleUnion& aValue, nsStyleUnit aUnit);
  92   ~nsStyleCoord() { Reset(); }
  93
  94   nsStyleCoord&  operator=(const nsStyleCoord& aOther)
  95   {
  96     if (this != &aOther) {
  97       SetValue(mUnit, mValue, aOther);
  98     }
  99     return *this;
 100   }
 101   bool           operator==(const nsStyleCoord& aOther) const;
 102   bool           operator!=(const nsStyleCoord& aOther) const;
 103
 104   nsStyleUnit GetUnit() const {
 105     NS_ASSERTION(mUnit != eStyleUnit_Null, "reading uninitialized value");
 106     return mUnit;
 107   }
 108
 109   bool IsAngleValue() const {
 110     return eStyleUnit_Degree <= mUnit && mUnit <= eStyleUnit_Turn;
 111   }
 112
 113   static bool IsCalcUnit(nsStyleUnit aUnit) {
 114     return aUnit == eStyleUnit_Calc;
 115   }
 116
 117   static bool IsPointerUnit(nsStyleUnit aUnit) {
 118     return IsCalcUnit(aUnit);
 119   }
 120
 121   bool IsCalcUnit() const {
 122     return IsCalcUnit(mUnit);
 123   }
 124
 125   bool IsPointerValue() const {
 126     return IsPointerUnit(mUnit);
 127   }
 128
 129   bool IsCoordPercentCalcUnit() const {
 130     return mUnit == eStyleUnit_Coord ||
 131            mUnit == eStyleUnit_Percent ||
 132            IsCalcUnit();
 133   }
 134
 135   // Does this calc() expression have any percentages inside it?  Can be
 136   // called only when IsCalcUnit() is true.
 137   bool CalcHasPercent() const {
 138     return GetCalcValue()->mHasPercent;
 139   }
 140
 141   bool HasPercent() const {
 142     return mUnit == eStyleUnit_Percent ||
 143            (IsCalcUnit() && CalcHasPercent());
 144   }
 145
 146   bool ConvertsToLength() const {
 147     return mUnit == eStyleUnit_Coord ||
 148            (IsCalcUnit() && !CalcHasPercent());
 149   }
 150
 151   nscoord     GetCoordValue() const;
 152   int32_t     GetIntValue() const;
 153   float       GetPercentValue() const;
 154   float       GetFactorValue() const;
 155   float       GetFactorOrPercentValue() const;
 156   float       GetAngleValue() const;
 157   double      GetAngleValueInDegrees() const;
 158   double      GetAngleValueInRadians() const;
 159   float       GetFlexFractionValue() const;
 160   Calc*       GetCalcValue() const;
 161   uint32_t    HashValue(uint32_t aHash) const;
 162
 163   // Sets to null and releases any refcounted objects.  Only use this if the
 164   // object is initialized (i.e. don't use it in nsStyleCoord constructors).
 165   void Reset();
 166
 167   void  SetCoordValue(nscoord aValue);
 168   void  SetIntValue(int32_t aValue, nsStyleUnit aUnit);
 169   void  SetPercentValue(float aValue);
 170   void  SetFactorValue(float aValue);
 171   void  SetAngleValue(float aValue, nsStyleUnit aUnit);
 172   void  SetFlexFractionValue(float aValue);
 173   void  SetNormalValue();
 174   void  SetAutoValue();
 175   void  SetNoneValue();
 176   void  SetCalcValue(Calc* aValue);
 177
 178   // Resets a coord represented by a unit/value pair.
 179   static inline void Reset(nsStyleUnit& aUnit, nsStyleUnion& aValue);
 180
 181   // Sets a coord represented by a unit/value pair from a second
 182   // unit/value pair.
 183   static inline void SetValue(nsStyleUnit& aUnit,
 184                               nsStyleUnion& aValue,
 185                               nsStyleUnit aOtherUnit,
 186                               const nsStyleUnion& aOtherValue);
 187
 188   // Sets a coord represented by a unit/value pair from an nsStyleCoord.
 189   static inline void SetValue(nsStyleUnit& aUnit, nsStyleUnion& aValue,
 190                               const nsStyleCoord& aOther);
 191
 192 private:
 193   nsStyleUnit   mUnit;
 194   nsStyleUnion  mValue;
 195 };
 196
 197 /**
 198  * Class that represents a set of top/right/bottom/left nsStyleCoords.
 199  * This is commonly used to hold the widths of the borders, margins,
 200  * or paddings of a box.
 201  */
 202 class nsStyleSides {
 203 public:
 204   nsStyleSides();
 205   nsStyleSides(const nsStyleSides&);
 206   ~nsStyleSides();
 207
 208   nsStyleSides&  operator=(const nsStyleSides& aCopy);
 209   bool           operator==(const nsStyleSides& aOther) const;
 210   bool           operator!=(const nsStyleSides& aOther) const;
 211
 212   inline nsStyleUnit GetUnit(mozilla::css::Side aSide) const;
 213   inline nsStyleUnit GetLeftUnit() const;
 214   inline nsStyleUnit GetTopUnit() const;
 215   inline nsStyleUnit GetRightUnit() const;
 216   inline nsStyleUnit GetBottomUnit() const;
 217
 218   inline nsStyleCoord Get(mozilla::css::Side aSide) const;
 219   inline nsStyleCoord GetLeft() const;
 220   inline nsStyleCoord GetTop() const;
 221   inline nsStyleCoord GetRight() const;
 222   inline nsStyleCoord GetBottom() const;
 223
 224   // Sets each side to null and releases any refcounted objects.  Only use this
 225   // if the object is initialized (i.e. don't use it in nsStyleSides
 226   // constructors).
 227   void Reset();
 228
 229   inline void Set(mozilla::css::Side aSide, const nsStyleCoord& aCoord);
 230   inline void SetLeft(const nsStyleCoord& aCoord);
 231   inline void SetTop(const nsStyleCoord& aCoord);
 232   inline void SetRight(const nsStyleCoord& aCoord);
 233   inline void SetBottom(const nsStyleCoord& aCoord);
 234
 235 protected:
 236   nsStyleUnit   mUnits[4];
 237   nsStyleUnion  mValues[4];
 238 };
 239
 240 /**
 241  * Class that represents a set of top-left/top-right/bottom-left/bottom-right
 242  * nsStyleCoord pairs.  This is used to hold the dimensions of the
 243  * corners of a box (for, e.g., border-radius and outline-radius).
 244  */
 245 class nsStyleCorners {
 246 public:
 247   nsStyleCorners();
 248   nsStyleCorners(const nsStyleCorners&);
 249   ~nsStyleCorners();
 250
 251   // use compiler's version
 252   nsStyleCorners& operator=(const nsStyleCorners& aCopy);
 253   bool           operator==(const nsStyleCorners& aOther) const;
 254   bool           operator!=(const nsStyleCorners& aOther) const;
 255
 256   // aCorner is always one of NS_CORNER_* defined in nsStyleConsts.h
 257   inline nsStyleUnit GetUnit(uint8_t aHalfCorner) const;
 258
 259   inline nsStyleCoord Get(uint8_t aHalfCorner) const;
 260
 261   // Sets each corner to null and releases any refcounted objects.  Only use
 262   // this if the object is initialized (i.e. don't use it in nsStyleCorners
 263   // constructors).
 264   void Reset();
 265
 266   inline void Set(uint8_t aHalfCorner, const nsStyleCoord& aCoord);
 267
 268 protected:
 269   nsStyleUnit   mUnits[8];
 270   nsStyleUnion  mValues[8];
 271 };
 272
 273
 274 // -------------------------
 275 // nsStyleCoord inlines
 276 //
 277 inline nsStyleCoord::nsStyleCoord(nscoord aValue, CoordConstructorType)
 278   : mUnit(eStyleUnit_Coord)
 279 {
 280   mValue.mInt = aValue;
 281 }
 282
 283 inline nsStyleCoord::nsStyleCoord(const nsStyleCoord& aCopy)
 284   : mUnit(eStyleUnit_Null)
 285 {
 286   SetValue(mUnit, mValue, aCopy);
 287 }
 288
 289 inline nsStyleCoord::nsStyleCoord(const nsStyleUnion& aValue, nsStyleUnit aUnit)
 290   : mUnit(eStyleUnit_Null)
 291 {
 292   SetValue(mUnit, mValue, aUnit, aValue);
 293 }
 294
 295 inline bool nsStyleCoord::operator!=(const nsStyleCoord& aOther) const
 296 {
 297   return !((*this) == aOther);
 298 }
 299
 300 inline nscoord nsStyleCoord::GetCoordValue() const
 301 {
 302   NS_ASSERTION((mUnit == eStyleUnit_Coord), "not a coord value");
 303   if (mUnit == eStyleUnit_Coord) {
 304     return mValue.mInt;
 305   }
 306   return 0;
 307 }
 308
 309 inline int32_t nsStyleCoord::GetIntValue() const
 310 {
 311   NS_ASSERTION((mUnit == eStyleUnit_Enumerated) ||
 312                (mUnit == eStyleUnit_Integer), "not an int value");
 313   if ((mUnit == eStyleUnit_Enumerated) ||
 314       (mUnit == eStyleUnit_Integer)) {
 315     return mValue.mInt;
 316   }
 317   return 0;
 318 }
 319
 320 inline float nsStyleCoord::GetPercentValue() const
 321 {
 322   NS_ASSERTION(mUnit == eStyleUnit_Percent, "not a percent value");
 323   if (mUnit == eStyleUnit_Percent) {
 324     return mValue.mFloat;
 325   }
 326   return 0.0f;
 327 }
 328
 329 inline float nsStyleCoord::GetFactorValue() const
 330 {
 331   NS_ASSERTION(mUnit == eStyleUnit_Factor, "not a factor value");
 332   if (mUnit == eStyleUnit_Factor) {
 333     return mValue.mFloat;
 334   }
 335   return 0.0f;
 336 }
 337
 338 inline float nsStyleCoord::GetFactorOrPercentValue() const
 339 {
 340   NS_ASSERTION(mUnit == eStyleUnit_Factor || mUnit == eStyleUnit_Percent,
 341                "not a percent or factor value");
 342   if (mUnit == eStyleUnit_Factor || mUnit == eStyleUnit_Percent) {
 343     return mValue.mFloat;
 344   }
 345   return 0.0f;
 346 }
 347
 348 inline float nsStyleCoord::GetAngleValue() const
 349 {
 350   NS_ASSERTION(mUnit >= eStyleUnit_Degree &&
 351                mUnit <= eStyleUnit_Turn, "not an angle value");
 352   if (mUnit >= eStyleUnit_Degree && mUnit <= eStyleUnit_Turn) {
 353     return mValue.mFloat;
 354   }
 355   return 0.0f;
 356 }
 357
 358 inline float nsStyleCoord::GetFlexFractionValue() const
 359 {
 360   NS_ASSERTION(mUnit == eStyleUnit_FlexFraction, "not a fr value");
 361   if (mUnit == eStyleUnit_FlexFraction) {
 362     return mValue.mFloat;
 363   }
 364   return 0.0f;
 365 }
 366
 367 inline nsStyleCoord::Calc* nsStyleCoord::GetCalcValue() const
 368 {
 369   NS_ASSERTION(IsCalcUnit(), "not a pointer value");
 370   if (IsCalcUnit()) {
 371     return static_cast<Calc*>(mValue.mPointer);
 372   }
 373   return nullptr;
 374 }
 375
 376 /* static */ inline void
 377 nsStyleCoord::Reset(nsStyleUnit& aUnit, nsStyleUnion& aValue)
 378 {
 379   MOZ_ASSERT(aUnit <= eStyleUnit_MAX,
 380              "calling Reset on uninitialized nsStyleCoord?");
 381
 382   switch (aUnit) {
 383     case eStyleUnit_Calc:
 384       static_cast<Calc*>(aValue.mPointer)->Release();
 385       break;
 386     default:
 387       MOZ_ASSERT(!IsPointerUnit(aUnit), "check pointer refcounting logic");
 388   }
 389
 390   aUnit = eStyleUnit_Null;
 391   aValue.mInt = 0;
 392 }
 393
 394 /* static */ inline void
 395 nsStyleCoord::SetValue(nsStyleUnit& aUnit,
 396                        nsStyleUnion& aValue,
 397                        nsStyleUnit aOtherUnit,
 398                        const nsStyleUnion& aOtherValue)
 399 {
 400   Reset(aUnit, aValue);
 401
 402   aUnit = aOtherUnit;
 403   aValue = aOtherValue;
 404
 405   switch (aUnit) {
 406     case eStyleUnit_Calc:
 407       static_cast<Calc*>(aValue.mPointer)->AddRef();
 408       break;
 409     default:
 410       MOZ_ASSERT(!IsPointerUnit(aUnit), "check pointer refcounting logic");
 411   }
 412 }
 413
 414 /* static */ inline void
 415 nsStyleCoord::SetValue(nsStyleUnit& aUnit, nsStyleUnion& aValue,
 416                        const nsStyleCoord& aOther)
 417 {
 418   SetValue(aUnit, aValue, aOther.mUnit, aOther.mValue);
 419 }
 420
 421
 422 // -------------------------
 423 // nsStyleSides inlines
 424 //
 425 inline bool nsStyleSides::operator!=(const nsStyleSides& aOther) const
 426 {
 427   return !((*this) == aOther);
 428 }
 429
 430 inline nsStyleUnit nsStyleSides::GetUnit(mozilla::css::Side aSide) const
 431 {
 432   return (nsStyleUnit)mUnits[aSide];
 433 }
 434
 435 inline nsStyleUnit nsStyleSides::GetLeftUnit() const
 436 {
 437   return GetUnit(NS_SIDE_LEFT);
 438 }
 439
 440 inline nsStyleUnit nsStyleSides::GetTopUnit() const
 441 {
 442   return GetUnit(NS_SIDE_TOP);
 443 }
 444
 445 inline nsStyleUnit nsStyleSides::GetRightUnit() const
 446 {
 447   return GetUnit(NS_SIDE_RIGHT);
 448 }
 449
 450 inline nsStyleUnit nsStyleSides::GetBottomUnit() const
 451 {
 452   return GetUnit(NS_SIDE_BOTTOM);
 453 }
 454
 455 inline nsStyleCoord nsStyleSides::Get(mozilla::css::Side aSide) const
 456 {
 457   return nsStyleCoord(mValues[aSide], nsStyleUnit(mUnits[aSide]));
 458 }
 459
 460 inline nsStyleCoord nsStyleSides::GetLeft() const
 461 {
 462   return Get(NS_SIDE_LEFT);
 463 }
 464
 465 inline nsStyleCoord nsStyleSides::GetTop() const
 466 {
 467   return Get(NS_SIDE_TOP);
 468 }
 469
 470 inline nsStyleCoord nsStyleSides::GetRight() const
 471 {
 472   return Get(NS_SIDE_RIGHT);
 473 }
 474
 475 inline nsStyleCoord nsStyleSides::GetBottom() const
 476 {
 477   return Get(NS_SIDE_BOTTOM);
 478 }
 479
 480 inline void nsStyleSides::Set(mozilla::css::Side aSide, const nsStyleCoord& aCoord)
 481 {
 482   nsStyleCoord::SetValue(mUnits[aSide], mValues[aSide], aCoord);
 483 }
 484
 485 inline void nsStyleSides::SetLeft(const nsStyleCoord& aCoord)
 486 {
 487   Set(NS_SIDE_LEFT, aCoord);
 488 }
 489
 490 inline void nsStyleSides::SetTop(const nsStyleCoord& aCoord)
 491 {
 492   Set(NS_SIDE_TOP, aCoord);
 493 }
 494
 495 inline void nsStyleSides::SetRight(const nsStyleCoord& aCoord)
 496 {
 497   Set(NS_SIDE_RIGHT, aCoord);
 498 }
 499
 500 inline void nsStyleSides::SetBottom(const nsStyleCoord& aCoord)
 501 {
 502   Set(NS_SIDE_BOTTOM, aCoord);
 503 }
 504
 505 // -------------------------
 506 // nsStyleCorners inlines
 507 //
 508 inline bool nsStyleCorners::operator!=(const nsStyleCorners& aOther) const
 509 {
 510   return !((*this) == aOther);
 511 }
 512
 513 inline nsStyleUnit nsStyleCorners::GetUnit(uint8_t aCorner) const
 514 {
 515   return (nsStyleUnit)mUnits[aCorner];
 516 }
 517
 518 inline nsStyleCoord nsStyleCorners::Get(uint8_t aCorner) const
 519 {
 520   return nsStyleCoord(mValues[aCorner], nsStyleUnit(mUnits[aCorner]));
 521 }
 522
 523 inline void nsStyleCorners::Set(uint8_t aCorner, const nsStyleCoord& aCoord)
 524 {
 525   nsStyleCoord::SetValue(mUnits[aCorner], mValues[aCorner], aCoord);
 526 }
 527
 528 #endif /* nsStyleCoord_h___ */