Home | History | Annotate | Download | only in platform 
      1 /*
      2     Copyright (C) 1999 Lars Knoll (knoll (at) kde.org)
      3     Copyright (C) 2006, 2008 Apple Inc. All rights reserved.
      4     Copyright (C) 2011 Rik Cabanier (cabanier (at) adobe.com)
      5     Copyright (C) 2011 Adobe Systems Incorporated. All rights reserved.
      6     Copyright (C) 2012 Motorola Mobility, Inc. All rights reserved.
      7 
      8     This library is free software; you can redistribute it and/or
      9     modify it under the terms of the GNU Library General Public
     10     License as published by the Free Software Foundation; either
     11     version 2 of the License, or (at your option) any later version.
     12 
     13     This library is distributed in the hope that it will be useful,
     14     but WITHOUT ANY WARRANTY; without even the implied warranty of
     15     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     16     Library General Public License for more details.
     17 
     18     You should have received a copy of the GNU Library General Public License
     19     along with this library; see the file COPYING.LIB.  If not, write to
     20     the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
     21     Boston, MA 02110-1301, USA.
     22 */
     23 
     24 #include "config.h"
     25 #include "platform/LengthFunctions.h"
     26 
     27 #include "platform/LayoutUnit.h"
     28 #include "platform/LengthSize.h"
     29 
     30 namespace blink {
     31 
     32 int intValueForLength(const Length& length, LayoutUnit maximumValue)
     33 {
     34     return static_cast<int>(valueForLength(length, maximumValue));
     35 }
     36 
     37 float floatValueForLength(const Length& length, float maximumValue)
     38 {
     39     switch (length.type()) {
     40     case Fixed:
     41         return length.getFloatValue();
     42     case Percent:
     43         return static_cast<float>(maximumValue * length.percent() / 100.0f);
     44     case FillAvailable:
     45     case Auto:
     46         return static_cast<float>(maximumValue);
     47     case Calculated:
     48         return length.nonNanCalculatedValue(maximumValue);
     49     case Intrinsic:
     50     case MinIntrinsic:
     51     case MinContent:
     52     case MaxContent:
     53     case FitContent:
     54     case ExtendToZoom:
     55     case DeviceWidth:
     56     case DeviceHeight:
     57     case MaxSizeNone:
     58         ASSERT_NOT_REACHED();
     59         return 0;
     60     }
     61     ASSERT_NOT_REACHED();
     62     return 0;
     63 }
     64 
     65 LayoutUnit minimumValueForLength(const Length& length, LayoutUnit maximumValue)
     66 {
     67     switch (length.type()) {
     68     case Fixed:
     69         return length.value();
     70     case Percent:
     71         // Don't remove the extra cast to float. It is needed for rounding on 32-bit Intel machines that use the FPU stack.
     72         return static_cast<float>(maximumValue * length.percent() / 100.0f);
     73     case Calculated:
     74         return length.nonNanCalculatedValue(maximumValue);
     75     case FillAvailable:
     76     case Auto:
     77         return 0;
     78     case Intrinsic:
     79     case MinIntrinsic:
     80     case MinContent:
     81     case MaxContent:
     82     case FitContent:
     83     case ExtendToZoom:
     84     case DeviceWidth:
     85     case DeviceHeight:
     86     case MaxSizeNone:
     87         ASSERT_NOT_REACHED();
     88         return 0;
     89     }
     90     ASSERT_NOT_REACHED();
     91     return 0;
     92 }
     93 
     94 LayoutUnit roundedMinimumValueForLength(const Length& length, LayoutUnit maximumValue)
     95 {
     96     if (length.type() == Percent)
     97         return static_cast<LayoutUnit>(round(maximumValue * length.percent() / 100.0f));
     98     return minimumValueForLength(length, maximumValue);
     99 }
    100 
    101 LayoutUnit valueForLength(const Length& length, LayoutUnit maximumValue)
    102 {
    103     switch (length.type()) {
    104     case Fixed:
    105     case Percent:
    106     case Calculated:
    107         return minimumValueForLength(length, maximumValue);
    108     case FillAvailable:
    109     case Auto:
    110         return maximumValue;
    111     case Intrinsic:
    112     case MinIntrinsic:
    113     case MinContent:
    114     case MaxContent:
    115     case FitContent:
    116     case ExtendToZoom:
    117     case DeviceWidth:
    118     case DeviceHeight:
    119     case MaxSizeNone:
    120         ASSERT_NOT_REACHED();
    121         return 0;
    122     }
    123     ASSERT_NOT_REACHED();
    124     return 0;
    125 }
    126 
    127 FloatSize floatSizeForLengthSize(const LengthSize& lengthSize, const FloatSize& boxSize)
    128 {
    129     return FloatSize(floatValueForLength(lengthSize.width(), boxSize.width()), floatValueForLength(lengthSize.height(), boxSize.height()));
    130 }
    131 
    132 } // namespace blink
    133