The Tor Browser / file revision

layout/style/nsStyleCoord.cpp@141e0f1194b1

layout/style/nsStyleCoord.cpp

Wed, 31 Dec 2014 07:16:47 +0100

author
Michael Schloh von Bennewitz <michael@schloh.com>
date
Wed, 31 Dec 2014 07:16:47 +0100
branch
TOR_BUG_9701
changeset 3
141e0f1194b1
permissions
-rw-r--r--

Revert simplistic fix pending revisit of Mozilla integration attempt.

     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 #include "nsStyleCoord.h"

     9 #include "mozilla/HashFunctions.h"

    10 

    11 nsStyleCoord::nsStyleCoord(nsStyleUnit aUnit)

    12   : mUnit(aUnit)

    13 {

    14   NS_ASSERTION(aUnit < eStyleUnit_Percent, "not a valueless unit");

    15   if (aUnit >= eStyleUnit_Percent) {

    16     mUnit = eStyleUnit_Null;

    17   }

    18   mValue.mInt = 0;

    19 }

    20 

    21 nsStyleCoord::nsStyleCoord(int32_t aValue, nsStyleUnit aUnit)

    22   : mUnit(aUnit)

    23 {

    24   //if you want to pass in eStyleUnit_Coord, don't. instead, use the

    25   //constructor just above this one... MMP

    26   NS_ASSERTION((aUnit == eStyleUnit_Enumerated) ||

    27                (aUnit == eStyleUnit_Integer), "not an int value");

    28   if ((aUnit == eStyleUnit_Enumerated) ||

    29       (aUnit == eStyleUnit_Integer)) {

    30     mValue.mInt = aValue;

    31   }

    32   else {

    33     mUnit = eStyleUnit_Null;

    34     mValue.mInt = 0;

    35   }

    36 }

    37 

    38 nsStyleCoord::nsStyleCoord(float aValue, nsStyleUnit aUnit)

    39   : mUnit(aUnit)

    40 {

    41   if (aUnit < eStyleUnit_Percent || aUnit >= eStyleUnit_Coord) {

    42     NS_NOTREACHED("not a float value");

    43     Reset();

    44   } else {

    45     mValue.mFloat = aValue;

    46   }

    47 }

    48 

    49 bool nsStyleCoord::operator==(const nsStyleCoord& aOther) const

    50 {

    51   if (mUnit != aOther.mUnit) {

    52     return false;

    53   }

    54   switch (mUnit) {

    55     case eStyleUnit_Null:

    56     case eStyleUnit_Normal:

    57     case eStyleUnit_Auto:

    58     case eStyleUnit_None:

    59       return true;

    60     case eStyleUnit_Percent:

    61     case eStyleUnit_Factor:

    62     case eStyleUnit_Degree:

    63     case eStyleUnit_Grad:

    64     case eStyleUnit_Radian:

    65     case eStyleUnit_Turn:

    66     case eStyleUnit_FlexFraction:

    67       return mValue.mFloat == aOther.mValue.mFloat;

    68     case eStyleUnit_Coord:

    69     case eStyleUnit_Integer:

    70     case eStyleUnit_Enumerated:

    71       return mValue.mInt == aOther.mValue.mInt;

    72     case eStyleUnit_Calc:

    73       return *this->GetCalcValue() == *aOther.GetCalcValue();

    74   }

    75   NS_ABORT_IF_FALSE(false, "unexpected unit");

    76   return false;

    77 }

    78 

    79 uint32_t nsStyleCoord::HashValue(uint32_t aHash = 0) const

    80 {

    81   aHash = mozilla::AddToHash(aHash, mUnit);

    82 

    83   switch (mUnit) {

    84     case eStyleUnit_Null:

    85     case eStyleUnit_Normal:

    86     case eStyleUnit_Auto:

    87     case eStyleUnit_None:

    88       return mozilla::AddToHash(aHash, true);

    89     case eStyleUnit_Percent:

    90     case eStyleUnit_Factor:

    91     case eStyleUnit_Degree:

    92     case eStyleUnit_Grad:

    93     case eStyleUnit_Radian:

    94     case eStyleUnit_Turn:

    95     case eStyleUnit_FlexFraction:

    96       return mozilla::AddToHash(aHash, mValue.mFloat);

    97     case eStyleUnit_Coord:

    98     case eStyleUnit_Integer:

    99     case eStyleUnit_Enumerated:

   100       return mozilla::AddToHash(aHash, mValue.mInt);

   101     case eStyleUnit_Calc:

   102       Calc* calcValue = GetCalcValue();

   103       aHash = mozilla::AddToHash(aHash, calcValue->mLength);

   104       if (HasPercent()) {

   105         return mozilla::AddToHash(aHash, calcValue->mPercent);

   106       }

   107       return aHash;

   108   }

   109   NS_ABORT_IF_FALSE(false, "unexpected unit");

   110   return aHash;

   111 }

   112 

   113 void nsStyleCoord::Reset()

   114 {

   115   mUnit = eStyleUnit_Null;

   116   mValue.mInt = 0;

   117 }

   118 

   119 void nsStyleCoord::SetCoordValue(nscoord aValue)

   120 {

   121   mUnit = eStyleUnit_Coord;

   122   mValue.mInt = aValue;

   123 }

   124 

   125 void nsStyleCoord::SetIntValue(int32_t aValue, nsStyleUnit aUnit)

   126 {

   127   NS_ASSERTION((aUnit == eStyleUnit_Enumerated) ||

   128                (aUnit == eStyleUnit_Integer), "not an int value");

   129   if ((aUnit == eStyleUnit_Enumerated) ||

   130       (aUnit == eStyleUnit_Integer)) {

   131     mUnit = aUnit;

   132     mValue.mInt = aValue;

   133   }

   134   else {

   135     Reset();

   136   }

   137 }

   138 

   139 void nsStyleCoord::SetPercentValue(float aValue)

   140 {

   141   mUnit = eStyleUnit_Percent;

   142   mValue.mFloat = aValue;

   143 }

   144 

   145 void nsStyleCoord::SetFactorValue(float aValue)

   146 {

   147   mUnit = eStyleUnit_Factor;

   148   mValue.mFloat = aValue;

   149 }

   150 

   151 void nsStyleCoord::SetAngleValue(float aValue, nsStyleUnit aUnit)

   152 {

   153   if (aUnit == eStyleUnit_Degree ||

   154       aUnit == eStyleUnit_Grad ||

   155       aUnit == eStyleUnit_Radian ||

   156       aUnit == eStyleUnit_Turn) {

   157     mUnit = aUnit;

   158     mValue.mFloat = aValue;

   159   } else {

   160     NS_NOTREACHED("not an angle value");

   161     Reset();

   162   }

   163 }

   164 

   165 void nsStyleCoord::SetFlexFractionValue(float aValue)

   166 {

   167   mUnit = eStyleUnit_FlexFraction;

   168   mValue.mFloat = aValue;

   169 }

   170 

   171 void nsStyleCoord::SetCalcValue(Calc* aValue)

   172 {

   173   mUnit = eStyleUnit_Calc;

   174   mValue.mPointer = aValue;

   175 }

   176 

   177 void nsStyleCoord::SetNormalValue()

   178 {

   179   mUnit = eStyleUnit_Normal;

   180   mValue.mInt = 0;

   181 }

   182 

   183 void nsStyleCoord::SetAutoValue()

   184 {

   185   mUnit = eStyleUnit_Auto;

   186   mValue.mInt = 0;

   187 }

   188 

   189 void nsStyleCoord::SetNoneValue()

   190 {

   191   mUnit = eStyleUnit_None;

   192   mValue.mInt = 0;

   193 }

   194 

   195 // accessors that are not inlined

   196 

   197 double

   198 nsStyleCoord::GetAngleValueInRadians() const

   199 {

   200   double angle = mValue.mFloat;

   201 

   202   switch (GetUnit()) {

   203   case eStyleUnit_Radian: return angle;

   204   case eStyleUnit_Turn:   return angle * 2 * M_PI;

   205   case eStyleUnit_Degree: return angle * M_PI / 180.0;

   206   case eStyleUnit_Grad:   return angle * M_PI / 200.0;

   207 

   208   default:

   209     NS_NOTREACHED("unrecognized angular unit");

   210     return 0.0;

   211   }

   212 }

   213 

   214 nsStyleSides::nsStyleSides()

   215 {

   216   memset(this, 0x00, sizeof(nsStyleSides));

   217 }

   218 

   219 bool nsStyleSides::operator==(const nsStyleSides& aOther) const

   220 {

   221   NS_FOR_CSS_SIDES(i) {

   222     if (nsStyleCoord(mValues[i], (nsStyleUnit)mUnits[i]) !=

   223         nsStyleCoord(aOther.mValues[i], (nsStyleUnit)aOther.mUnits[i])) {

   224       return false;

   225     }

   226   }

   227   return true;

   228 }

   229 

   230 void nsStyleSides::Reset()

   231 {

   232   memset(this, 0x00, sizeof(nsStyleSides));

   233 }

   234 

   235 nsStyleCorners::nsStyleCorners()

   236 {

   237   memset(this, 0x00, sizeof(nsStyleCorners));

   238 }

   239 

   240 bool

   241 nsStyleCorners::operator==(const nsStyleCorners& aOther) const

   242 {

   243   NS_FOR_CSS_HALF_CORNERS(i) {

   244     if (nsStyleCoord(mValues[i], (nsStyleUnit)mUnits[i]) !=

   245         nsStyleCoord(aOther.mValues[i], (nsStyleUnit)aOther.mUnits[i])) {

   246       return false;

   247     }

   248   }

   249   return true;

   250 }

   251 

   252 void nsStyleCorners::Reset()

   253 {

   254   memset(this, 0x00, sizeof(nsStyleCorners));

   255 }

   256 

   257 // Validation of NS_SIDE_IS_VERTICAL and NS_HALF_CORNER_IS_X.

   258 #define CASE(side, result)                                                    \

   259   static_assert(NS_SIDE_IS_VERTICAL(side) == result,                      \

   260                 "NS_SIDE_IS_VERTICAL is wrong")

   261 CASE(NS_SIDE_TOP,    false);

   262 CASE(NS_SIDE_RIGHT,  true);

   263 CASE(NS_SIDE_BOTTOM, false);

   264 CASE(NS_SIDE_LEFT,   true);

   265 #undef CASE

   266 

   267 #define CASE(corner, result)                                                  \

   268   static_assert(NS_HALF_CORNER_IS_X(corner) == result,                    \

   269                 "NS_HALF_CORNER_IS_X is wrong")

   270 CASE(NS_CORNER_TOP_LEFT_X,     true);

   271 CASE(NS_CORNER_TOP_LEFT_Y,     false);

   272 CASE(NS_CORNER_TOP_RIGHT_X,    true);

   273 CASE(NS_CORNER_TOP_RIGHT_Y,    false);

   274 CASE(NS_CORNER_BOTTOM_RIGHT_X, true);

   275 CASE(NS_CORNER_BOTTOM_RIGHT_Y, false);

   276 CASE(NS_CORNER_BOTTOM_LEFT_X,  true);

   277 CASE(NS_CORNER_BOTTOM_LEFT_Y,  false);

   278 #undef CASE

   279 

   280 // Validation of NS_HALF_TO_FULL_CORNER.

   281 #define CASE(corner, result)                                                  \

   282   static_assert(NS_HALF_TO_FULL_CORNER(corner) == result,                 \

   283                 "NS_HALF_TO_FULL_CORNER is wrong")

   284 CASE(NS_CORNER_TOP_LEFT_X,     NS_CORNER_TOP_LEFT);

   285 CASE(NS_CORNER_TOP_LEFT_Y,     NS_CORNER_TOP_LEFT);

   286 CASE(NS_CORNER_TOP_RIGHT_X,    NS_CORNER_TOP_RIGHT);

   287 CASE(NS_CORNER_TOP_RIGHT_Y,    NS_CORNER_TOP_RIGHT);

   288 CASE(NS_CORNER_BOTTOM_RIGHT_X, NS_CORNER_BOTTOM_RIGHT);

   289 CASE(NS_CORNER_BOTTOM_RIGHT_Y, NS_CORNER_BOTTOM_RIGHT);

   290 CASE(NS_CORNER_BOTTOM_LEFT_X,  NS_CORNER_BOTTOM_LEFT);

   291 CASE(NS_CORNER_BOTTOM_LEFT_Y,  NS_CORNER_BOTTOM_LEFT);

   292 #undef CASE

   293 

   294 // Validation of NS_FULL_TO_HALF_CORNER.

   295 #define CASE(corner, vert, result)                                            \

   296   static_assert(NS_FULL_TO_HALF_CORNER(corner, vert) == result,           \

   297                 "NS_FULL_TO_HALF_CORNER is wrong")

   298 CASE(NS_CORNER_TOP_LEFT,     false, NS_CORNER_TOP_LEFT_X);

   299 CASE(NS_CORNER_TOP_LEFT,     true,  NS_CORNER_TOP_LEFT_Y);

   300 CASE(NS_CORNER_TOP_RIGHT,    false, NS_CORNER_TOP_RIGHT_X);

   301 CASE(NS_CORNER_TOP_RIGHT,    true,  NS_CORNER_TOP_RIGHT_Y);

   302 CASE(NS_CORNER_BOTTOM_RIGHT, false, NS_CORNER_BOTTOM_RIGHT_X);

   303 CASE(NS_CORNER_BOTTOM_RIGHT, true,  NS_CORNER_BOTTOM_RIGHT_Y);

   304 CASE(NS_CORNER_BOTTOM_LEFT,  false, NS_CORNER_BOTTOM_LEFT_X);

   305 CASE(NS_CORNER_BOTTOM_LEFT,  true,  NS_CORNER_BOTTOM_LEFT_Y);

   306 #undef CASE

   307 

   308 // Validation of NS_SIDE_TO_{FULL,HALF}_CORNER.

   309 #define CASE(side, second, result)                                            \

   310   static_assert(NS_SIDE_TO_FULL_CORNER(side, second) == result,           \

   311                 "NS_SIDE_TO_FULL_CORNER is wrong")

   312 CASE(NS_SIDE_TOP,    false, NS_CORNER_TOP_LEFT);

   313 CASE(NS_SIDE_TOP,    true,  NS_CORNER_TOP_RIGHT);

   314 

   315 CASE(NS_SIDE_RIGHT,  false, NS_CORNER_TOP_RIGHT);

   316 CASE(NS_SIDE_RIGHT,  true,  NS_CORNER_BOTTOM_RIGHT);

   317 

   318 CASE(NS_SIDE_BOTTOM, false, NS_CORNER_BOTTOM_RIGHT);

   319 CASE(NS_SIDE_BOTTOM, true,  NS_CORNER_BOTTOM_LEFT);

   320 

   321 CASE(NS_SIDE_LEFT,   false, NS_CORNER_BOTTOM_LEFT);

   322 CASE(NS_SIDE_LEFT,   true,  NS_CORNER_TOP_LEFT);

   323 #undef CASE

   324 

   325 #define CASE(side, second, parallel, result)                                  \

   326   static_assert(NS_SIDE_TO_HALF_CORNER(side, second, parallel) == result, \

   327                 "NS_SIDE_TO_HALF_CORNER is wrong")

   328 CASE(NS_SIDE_TOP,    false, true,  NS_CORNER_TOP_LEFT_X);

   329 CASE(NS_SIDE_TOP,    false, false, NS_CORNER_TOP_LEFT_Y);

   330 CASE(NS_SIDE_TOP,    true,  true,  NS_CORNER_TOP_RIGHT_X);

   331 CASE(NS_SIDE_TOP,    true,  false, NS_CORNER_TOP_RIGHT_Y);

   332 

   333 CASE(NS_SIDE_RIGHT,  false, false, NS_CORNER_TOP_RIGHT_X);

   334 CASE(NS_SIDE_RIGHT,  false, true,  NS_CORNER_TOP_RIGHT_Y);

   335 CASE(NS_SIDE_RIGHT,  true,  false, NS_CORNER_BOTTOM_RIGHT_X);

   336 CASE(NS_SIDE_RIGHT,  true,  true,  NS_CORNER_BOTTOM_RIGHT_Y);

   337 

   338 CASE(NS_SIDE_BOTTOM, false, true,  NS_CORNER_BOTTOM_RIGHT_X);

   339 CASE(NS_SIDE_BOTTOM, false, false, NS_CORNER_BOTTOM_RIGHT_Y);

   340 CASE(NS_SIDE_BOTTOM, true,  true,  NS_CORNER_BOTTOM_LEFT_X);

   341 CASE(NS_SIDE_BOTTOM, true,  false, NS_CORNER_BOTTOM_LEFT_Y);

   342 

   343 CASE(NS_SIDE_LEFT,   false, false, NS_CORNER_BOTTOM_LEFT_X);

   344 CASE(NS_SIDE_LEFT,   false, true,  NS_CORNER_BOTTOM_LEFT_Y);

   345 CASE(NS_SIDE_LEFT,   true,  false, NS_CORNER_TOP_LEFT_X);

   346 CASE(NS_SIDE_LEFT,   true,  true,  NS_CORNER_TOP_LEFT_Y);

   347 #undef CASE

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial