webkitgtk-2.4.11webkitgtk-2.4.11

1 files changed, 80 insertions, 21 deletions

diff --git a/Source/WebCore/css/LengthFunctions.cpp b/Source/WebCore/css/LengthFunctions.cpp
index cf1c0216e..adba10081 100644
--- a/Source/WebCore/css/LengthFunctions.cpp
+++ b/Source/WebCore/css/LengthFunctions.cpp
@@ -24,34 +24,54 @@
 #include "config.h"
 #include "LengthFunctions.h"
 
-#include "FloatSize.h"
 #include "LayoutUnit.h"
-#include "LengthSize.h"
+#include "Length.h"
+#include "RenderView.h"
 
 namespace WebCore {
 
-int minimumIntValueForLength(const Length& length, LayoutUnit maximumValue, bool roundPercentages)
+int minimumIntValueForLength(const Length& length, LayoutUnit maximumValue, RenderView* renderView, bool roundPercentages)
 {
-    return static_cast<int>(minimumValueForLength(length, maximumValue, roundPercentages));
+    return static_cast<int>(minimumValueForLength(length, maximumValue, renderView, roundPercentages));
 }
 
-int intValueForLength(const Length& length, LayoutUnit maximumValue)
+int intValueForLength(const Length& length, LayoutUnit maximumValue, RenderView* renderView, bool roundPercentages)
 {
-    return static_cast<int>(valueForLength(length, maximumValue));
+    return static_cast<int>(valueForLength(length, maximumValue, renderView, roundPercentages));
 }
 
-LayoutUnit minimumValueForLength(const Length& length, LayoutUnit maximumValue, bool roundPercentages)
+LayoutUnit minimumValueForLength(const Length& length, LayoutUnit maximumValue, RenderView* renderView, bool roundPercentages)
 {
     switch (length.type()) {
     case Fixed:
         return length.value();
     case Percent:
         if (roundPercentages)
-            return LayoutUnit(round(maximumValue * length.percent() / 100.0f));
+            return static_cast<LayoutUnit>(round(maximumValue * length.percent() / 100.0f));
         // Don't remove the extra cast to float. It is needed for rounding on 32-bit Intel machines that use the FPU stack.
-        return LayoutUnit(static_cast<float>(maximumValue * length.percent() / 100.0f));
+        return static_cast<LayoutUnit>(static_cast<float>(maximumValue * length.percent() / 100.0f));
     case Calculated:
         return length.nonNanCalculatedValue(maximumValue);
+    case ViewportPercentageWidth:
+        if (renderView)
+            return static_cast<LayoutUnit>(renderView->viewportSize().width() * length.viewportPercentageLength() / 100.0f);
+        return 0;
+    case ViewportPercentageHeight:
+        if (renderView)
+            return static_cast<LayoutUnit>(renderView->viewportSize().height() * length.viewportPercentageLength() / 100.0f);
+        return 0;
+    case ViewportPercentageMin:
+        if (renderView) {
+            IntSize viewportSize = renderView->viewportSize();
+            return static_cast<LayoutUnit>(std::min(viewportSize.width(), viewportSize.height()) * length.viewportPercentageLength() / 100.0f);
+        }
+        return 0;
+    case ViewportPercentageMax:
+        if (renderView) {
+            IntSize viewportSize = renderView->viewportSize();
+            return static_cast<LayoutUnit>(std::max(viewportSize.width(), viewportSize.height()) * length.viewportPercentageLength() / 100.0f);
+        }
+        return 0;
     case FillAvailable:
     case Auto:
         return 0;
@@ -69,13 +89,17 @@ LayoutUnit minimumValueForLength(const Length& length, LayoutUnit maximumValue,
     return 0;
 }
 
-LayoutUnit valueForLength(const Length& length, LayoutUnit maximumValue)
+LayoutUnit valueForLength(const Length& length, LayoutUnit maximumValue, RenderView* renderView, bool roundPercentages)
 {
     switch (length.type()) {
     case Fixed:
     case Percent:
     case Calculated:
-        return minimumValueForLength(length, maximumValue);
+    case ViewportPercentageWidth:
+    case ViewportPercentageHeight:
+    case ViewportPercentageMin:
+    case ViewportPercentageMax:
+        return minimumValueForLength(length, maximumValue, renderView, roundPercentages);
     case FillAvailable:
     case Auto:
         return maximumValue;
@@ -94,18 +118,38 @@ LayoutUnit valueForLength(const Length& length, LayoutUnit maximumValue)
 }
 
 // FIXME: when subpixel layout is supported this copy of floatValueForLength() can be removed. See bug 71143.
-float floatValueForLength(const Length& length, LayoutUnit maximumValue)
+float floatValueForLength(const Length& length, LayoutUnit maximumValue, RenderView* renderView)
 {
     switch (length.type()) {
     case Fixed:
-        return length.value();
+        return length.getFloatValue();
     case Percent:
         return static_cast<float>(maximumValue * length.percent() / 100.0f);
     case FillAvailable:
     case Auto:
         return static_cast<float>(maximumValue);
     case Calculated:
-        return length.nonNanCalculatedValue(maximumValue);
+        return length.nonNanCalculatedValue(maximumValue);                
+    case ViewportPercentageWidth:
+        if (renderView)
+            return static_cast<int>(renderView->viewportSize().width() * length.viewportPercentageLength() / 100.0f);
+        return 0;
+    case ViewportPercentageHeight:
+        if (renderView)
+            return static_cast<int>(renderView->viewportSize().height() * length.viewportPercentageLength() / 100.0f);
+        return 0;
+    case ViewportPercentageMin:
+        if (renderView) {
+            IntSize viewportSize = renderView->viewportSize();
+            return static_cast<int>(std::min(viewportSize.width(), viewportSize.height()) * length.viewportPercentageLength() / 100.0f);
+        }
+        return 0;
+    case ViewportPercentageMax:
+        if (renderView) {
+            IntSize viewportSize = renderView->viewportSize();
+            return static_cast<int>(std::max(viewportSize.width(), viewportSize.height()) * length.viewportPercentageLength() / 100.0f);
+        }
+        return 0;
     case Relative:
     case Intrinsic:
     case MinIntrinsic:
@@ -120,11 +164,11 @@ float floatValueForLength(const Length& length, LayoutUnit maximumValue)
     return 0;
 }
 
-float floatValueForLength(const Length& length, float maximumValue)
+float floatValueForLength(const Length& length, float maximumValue, RenderView* renderView)
 {
     switch (length.type()) {
     case Fixed:
-        return length.value();
+        return length.getFloatValue();
     case Percent:
         return static_cast<float>(maximumValue * length.percent() / 100.0f);
     case FillAvailable:
@@ -132,6 +176,26 @@ float floatValueForLength(const Length& length, float maximumValue)
         return static_cast<float>(maximumValue);
     case Calculated:
         return length.nonNanCalculatedValue(maximumValue);
+    case ViewportPercentageWidth:
+        if (renderView)
+            return static_cast<int>(renderView->viewportSize().width() * length.viewportPercentageLength() / 100.0f);
+        return 0;
+    case ViewportPercentageHeight:
+        if (renderView)
+            return static_cast<int>(renderView->viewportSize().height() * length.viewportPercentageLength() / 100.0f);
+        return 0;
+    case ViewportPercentageMin:
+        if (renderView) {
+            IntSize viewportSize = renderView->viewportSize();
+            return static_cast<int>(std::min(viewportSize.width(), viewportSize.height()) * length.viewportPercentageLength() / 100.0f);
+        }
+        return 0;
+    case ViewportPercentageMax:
+        if (renderView) {
+            IntSize viewportSize = renderView->viewportSize();
+            return static_cast<int>(std::max(viewportSize.width(), viewportSize.height()) * length.viewportPercentageLength() / 100.0f);
+        }
+        return 0;
     case Relative:
     case Intrinsic:
     case MinIntrinsic:
@@ -146,9 +210,4 @@ float floatValueForLength(const Length& length, float maximumValue)
     return 0;
 }
 
-FloatSize floatSizeForLengthSize(const LengthSize& lengthSize, const FloatSize& boxSize)
-{
-    return FloatSize(floatValueForLength(lengthSize.width(), boxSize.width()), floatValueForLength(lengthSize.height(), boxSize.height()));
-}
-
 } // namespace WebCore