Move Shadow DOM renderers into rendering/

Source/core/rendering/RenderSliderContainer.cpp

+// Copyright 2014 The Chromium Authors. All rights reserved.

[tkent, 2014/07/17 23:56:13]

Please use the copyright header of SliderThumbElement.cpp.

[deepak.sa, 2014/07/18 06:06:56]

Done.

+//
+// The Chromium Authors can be found at
+// http://src.chromium.org/svn/trunk/src/AUTHORS
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//    * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//    * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//    * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#include "config.h"
+#include "core/rendering/RenderSliderContainer.h"
+
+#include "core/dom/shadow/ShadowRoot.h"
+#include "core/html/HTMLInputElement.h"
+#include "core/html/parser/HTMLParserIdioms.h"
+#include "core/html/shadow/ShadowElementNames.h"
+#include "core/html/shadow/SliderThumbElement.h"
+#include "core/rendering/RenderFlexibleBox.h"
+#include "core/rendering/RenderSlider.h"
+#include "core/rendering/RenderTheme.h"
+
+namespace WebCore {
+
+RenderSliderContainer::RenderSliderContainer(SliderContainerElement* element)
+    : RenderFlexibleBox(element)
+{
+}
+
+inline static Decimal sliderPosition(HTMLInputElement* element)
+{
+    const StepRange stepRange(element->createStepRange(RejectAny));
+    const Decimal oldValue = parseToDecimalForNumberType(element->value(), stepRange.defaultValue());
+    return stepRange.proportionFromValue(stepRange.clampValue(oldValue));
+}
+
+inline static bool hasVerticalAppearance(HTMLInputElement* input)
+{
+    ASSERT(input->renderer());
+    RenderStyle* sliderStyle = input->renderer()->style();
+
+    return sliderStyle->appearance() == SliderVerticalPart;
+}
+
+void RenderSliderContainer::computeLogicalHeight(LayoutUnit logicalHeight, LayoutUnit logicalTop, LogicalExtentComputedValues& computedValues) const
+{
+    HTMLInputElement* input = toHTMLInputElement(node()->shadowHost());
+    bool isVertical = hasVerticalAppearance(input);
+
+    if (input->renderer()->isSlider() && !isVertical && input->list()) {
+        int offsetFromCenter = RenderTheme::theme().sliderTickOffsetFromTrackCenter();
+        LayoutUnit trackHeight = 0;
+        if (offsetFromCenter < 0) {
+            trackHeight = -2 * offsetFromCenter;
+        } else {
+            int tickLength = RenderTheme::theme().sliderTickSize().height();
+            trackHeight = 2 * (offsetFromCenter + tickLength);
+        }
+        float zoomFactor = style()->effectiveZoom();
+        if (zoomFactor != 1.0)
+            trackHeight *= zoomFactor;
+
+        // FIXME: The trackHeight should have been added before updateLogicalHeight was called to avoid this hack.
+        updateIntrinsicContentLogicalHeight(trackHeight);
+
+        RenderBox::computeLogicalHeight(trackHeight, logicalTop, computedValues);
+        return;
+    }
+    if (isVertical)
+        logicalHeight = RenderSlider::defaultTrackLength;
+
+    // FIXME: The trackHeight should have been added before updateLogicalHeight was called to avoid this hack.
+    updateIntrinsicContentLogicalHeight(logicalHeight);
+
+    RenderBox::computeLogicalHeight(logicalHeight, logicalTop, computedValues);
+}
+
+void RenderSliderContainer::layout()
+{
+    HTMLInputElement* input = toHTMLInputElement(node()->shadowHost());
+    bool isVertical = hasVerticalAppearance(input);
+    style()->setFlexDirection(isVertical ? FlowColumn : FlowRow);
+    TextDirection oldTextDirection = style()->direction();
+    if (isVertical) {
+        // FIXME: Work around rounding issues in RTL vertical sliders. We want them to
+        // render identically to LTR vertical sliders. We can remove this work around when
+        // subpixel rendering is enabled on all ports.
+        style()->setDirection(LTR);
+    }
+
+    Element* thumbElement = input->userAgentShadowRoot()->getElementById(ShadowElementNames::sliderThumb());
+    Element* trackElement = input->userAgentShadowRoot()->getElementById(ShadowElementNames::sliderTrack());
+    RenderBox* thumb = thumbElement ? thumbElement->renderBox() : 0;
+    RenderBox* track = trackElement ? trackElement->renderBox() : 0;
+
+    SubtreeLayoutScope layoutScope(*this);
+    // Force a layout to reset the position of the thumb so the code below doesn't move the thumb to the wrong place.
+    // FIXME: Make a custom Render class for the track and move the thumb positioning code there.
+    if (track)
+        layoutScope.setChildNeedsLayout(track);
+
+    RenderFlexibleBox::layout();
+
+    style()->setDirection(oldTextDirection);
+    // These should always exist, unless someone mutates the shadow DOM (e.g., in the inspector).
+    if (!thumb || !track)
+        return;
+
+    double percentageOffset = sliderPosition(input).toDouble();
+    LayoutUnit availableExtent = isVertical ? track->contentHeight() : track->contentWidth();
+    availableExtent -= isVertical ? thumb->height() : thumb->width();
+    LayoutUnit offset = percentageOffset * availableExtent;
+    LayoutPoint thumbLocation = thumb->location();
+    if (isVertical)
+        thumbLocation.setY(thumbLocation.y() + track->contentHeight() - thumb->height() - offset);
+    else if (style()->isLeftToRightDirection())
+        thumbLocation.setX(thumbLocation.x() + offset);
+    else
+        thumbLocation.setX(thumbLocation.x() - offset);
+    thumb->setLocation(thumbLocation);
+}
+
+} // namespace WebCore