4e714a0391e46cb1ed2ba1eea54142b27b509446
[WebKit-https.git] / Source / WebCore / html / shadow / SliderThumbElement.cpp
1 /*
2  * Copyright (C) 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
3  * Copyright (C) 2010 Google Inc. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions are
7  * met:
8  *
9  *     * Redistributions of source code must retain the above copyright
10  * notice, this list of conditions and the following disclaimer.
11  *     * Redistributions in binary form must reproduce the above
12  * copyright notice, this list of conditions and the following disclaimer
13  * in the documentation and/or other materials provided with the
14  * distribution.
15  *     * Neither the name of Google Inc. nor the names of its
16  * contributors may be used to endorse or promote products derived from
17  * this software without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30  */
31
32
33 #include "config.h"
34 #include "SliderThumbElement.h"
35
36 #include "CSSValueKeywords.h"
37 #include "ElementShadow.h"
38 #include "Event.h"
39 #include "Frame.h"
40 #include "HTMLInputElement.h"
41 #include "HTMLParserIdioms.h"
42 #include "MouseEvent.h"
43 #include "RenderDeprecatedFlexibleBox.h"
44 #include "RenderSlider.h"
45 #include "RenderTheme.h"
46 #include "ShadowRoot.h"
47 #include "StepRange.h"
48 #include <wtf/MathExtras.h>
49
50 using namespace std;
51
52 namespace WebCore {
53
54 inline static InputNumber sliderPosition(HTMLInputElement* element)
55 {
56     const StepRange stepRange(element->createStepRange(RejectAny));
57     const InputNumber oldValue = parseToDecimalForNumberType(element->value(), stepRange.defaultValue());
58     return stepRange.proportionFromValue(stepRange.clampValue(oldValue));
59 }
60
61 inline static bool hasVerticalAppearance(HTMLInputElement* input)
62 {
63     ASSERT(input->renderer());
64     RenderStyle* sliderStyle = input->renderer()->style();
65     return sliderStyle->appearance() == SliderVerticalPart || sliderStyle->appearance() == MediaVolumeSliderPart;
66 }
67
68 SliderThumbElement* sliderThumbElementOf(Node* node)
69 {
70     ASSERT(node);
71     ShadowRoot* shadow = node->toInputElement()->shadow()->oldestShadowRoot();
72     ASSERT(shadow);
73     Node* thumb = shadow->firstChild()->firstChild()->firstChild();
74     ASSERT(thumb);
75     return toSliderThumbElement(thumb);
76 }
77
78 // --------------------------------
79
80 RenderSliderThumb::RenderSliderThumb(Node* node)
81     : RenderBlock(node)
82 {
83 }
84
85 void RenderSliderThumb::updateAppearance(RenderStyle* parentStyle)
86 {
87     if (parentStyle->appearance() == SliderVerticalPart)
88         style()->setAppearance(SliderThumbVerticalPart);
89     else if (parentStyle->appearance() == SliderHorizontalPart)
90         style()->setAppearance(SliderThumbHorizontalPart);
91     else if (parentStyle->appearance() == MediaSliderPart)
92         style()->setAppearance(MediaSliderThumbPart);
93     else if (parentStyle->appearance() == MediaVolumeSliderPart)
94         style()->setAppearance(MediaVolumeSliderThumbPart);
95     else if (parentStyle->appearance() == MediaFullScreenVolumeSliderPart)
96         style()->setAppearance(MediaFullScreenVolumeSliderThumbPart);
97     if (style()->hasAppearance())
98         theme()->adjustSliderThumbSize(style(), toElement(node()));
99 }
100
101 bool RenderSliderThumb::isSliderThumb() const
102 {
103     return true;
104 }
105
106 void RenderSliderThumb::layout()
107 {
108     // Do not cast node() to SliderThumbElement. This renderer is used for
109     // TrackLimitElement too.
110     HTMLInputElement* input = node()->shadowAncestorNode()->toInputElement();
111     bool isVertical = style()->appearance() == SliderThumbVerticalPart || style()->appearance() == MediaVolumeSliderThumbPart;
112
113     double fraction = convertInputNumberToDouble(sliderPosition(input) * 100);
114     if (isVertical)
115         style()->setTop(Length(100 - fraction, Percent));
116     else if (style()->isLeftToRightDirection())
117         style()->setLeft(Length(fraction, Percent));
118     else
119         style()->setRight(Length(fraction, Percent));
120
121     RenderBlock::layout();
122 }
123
124 // --------------------------------
125
126 // FIXME: Find a way to cascade appearance and adjust heights, and get rid of this class.
127 // http://webkit.org/b/62535
128 class RenderSliderContainer : public RenderDeprecatedFlexibleBox {
129 public:
130     RenderSliderContainer(Node* node)
131         : RenderDeprecatedFlexibleBox(node) { }
132
133 private:
134     virtual void layout();
135 };
136
137 void RenderSliderContainer::layout()
138 {
139     HTMLInputElement* input = node()->shadowAncestorNode()->toInputElement();
140     bool isVertical = hasVerticalAppearance(input);
141     style()->setBoxOrient(isVertical ? VERTICAL : HORIZONTAL);
142     // Sets the concrete height if the height of the <input> is not fixed or a
143     // percentage value because a percentage height value of this box won't be
144     // based on the <input> height in such case.
145     Length inputHeight = input->renderer()->style()->height();
146     RenderObject* trackRenderer = node()->firstChild()->renderer();
147     if (!isVertical && input->renderer()->isSlider() && !inputHeight.isFixed() && !inputHeight.isPercent()) {
148         RenderObject* thumbRenderer = input->shadow()->oldestShadowRoot()->firstChild()->firstChild()->firstChild()->renderer();
149         if (thumbRenderer) {
150             style()->setHeight(thumbRenderer->style()->height());
151             if (trackRenderer)
152                 trackRenderer->style()->setHeight(thumbRenderer->style()->height());
153         }
154     } else {
155         style()->setHeight(Length(100, Percent));
156         if (trackRenderer)
157             trackRenderer->style()->setHeight(Length());
158     }
159
160     RenderDeprecatedFlexibleBox::layout();
161
162     // Percentage 'top' for the thumb doesn't work if the parent style has no
163     // concrete height.
164     Node* track = node()->firstChild();
165     if (track && track->renderer()->isBox()) {
166         RenderBox* trackBox = track->renderBox();
167         trackBox->style()->setHeight(Length(trackBox->height() - trackBox->borderAndPaddingHeight(), Fixed));
168     }
169 }
170
171 // --------------------------------
172
173 void SliderThumbElement::setPositionFromValue()
174 {
175     // Since the code to calculate position is in the RenderSliderThumb layout
176     // path, we don't actually update the value here. Instead, we poke at the
177     // renderer directly to trigger layout.
178     if (renderer())
179         renderer()->setNeedsLayout(true);
180 }
181
182 RenderObject* SliderThumbElement::createRenderer(RenderArena* arena, RenderStyle*)
183 {
184     return new (arena) RenderSliderThumb(this);
185 }
186
187 bool SliderThumbElement::isEnabledFormControl() const
188 {
189     return hostInput()->isEnabledFormControl();
190 }
191
192 bool SliderThumbElement::isReadOnlyFormControl() const
193 {
194     return hostInput()->isReadOnlyFormControl();
195 }
196
197 Node* SliderThumbElement::focusDelegate()
198 {
199     return hostInput();
200 }
201
202 void SliderThumbElement::dragFrom(const LayoutPoint& point)
203 {
204     setPositionFromPoint(point);
205     startDragging();
206 }
207
208 void SliderThumbElement::setPositionFromPoint(const LayoutPoint& point)
209 {
210     HTMLInputElement* input = hostInput();
211
212     if (!input->renderer() || !renderer())
213         return;
214
215     LayoutPoint offset = roundedLayoutPoint(input->renderer()->absoluteToLocal(point, false, true));
216     bool isVertical = hasVerticalAppearance(input);
217     LayoutUnit trackSize;
218     LayoutUnit position;
219     LayoutUnit currentPosition;
220     // We need to calculate currentPosition from absolute points becaue the
221     // renderer for this node is usually on a layer and renderBox()->x() and
222     // y() are unusable.
223     // FIXME: This should probably respect transforms.
224     LayoutPoint absoluteThumbOrigin = renderBox()->absoluteBoundingBoxRectIgnoringTransforms().location();
225     LayoutPoint absoluteSliderContentOrigin = roundedLayoutPoint(input->renderer()->localToAbsolute());
226     if (isVertical) {
227         trackSize = input->renderBox()->contentHeight() - renderBox()->height();
228         position = offset.y() - renderBox()->height() / 2;
229         currentPosition = absoluteThumbOrigin.y() - absoluteSliderContentOrigin.y();
230     } else {
231         trackSize = input->renderBox()->contentWidth() - renderBox()->width();
232         position = offset.x() - renderBox()->width() / 2;
233         currentPosition = absoluteThumbOrigin.x() - absoluteSliderContentOrigin.x();
234     }
235     position = max<LayoutUnit>(0, min(position, trackSize));
236     if (position == currentPosition)
237         return;
238
239     const InputNumber ratio = convertDoubleToInputNumber(static_cast<double>(position) / trackSize);
240     const InputNumber fraction = isVertical || !renderBox()->style()->isLeftToRightDirection() ? InputNumber(1) - ratio : ratio;
241     StepRange stepRange(input->createStepRange(RejectAny));
242     const InputNumber value = stepRange.clampValue(stepRange.valueFromProportion(fraction));
243
244     // FIXME: This is no longer being set from renderer. Consider updating the method name.
245     input->setValueFromRenderer(serializeForNumberType(value));
246     renderer()->setNeedsLayout(true);
247     input->dispatchFormControlChangeEvent();
248 }
249
250 void SliderThumbElement::startDragging()
251 {
252     if (Frame* frame = document()->frame()) {
253         frame->eventHandler()->setCapturingMouseEventsNode(this);
254         m_inDragMode = true;
255     }
256 }
257
258 void SliderThumbElement::stopDragging()
259 {
260     if (!m_inDragMode)
261         return;
262
263     if (Frame* frame = document()->frame())
264         frame->eventHandler()->setCapturingMouseEventsNode(0);
265     m_inDragMode = false;
266     if (renderer())
267         renderer()->setNeedsLayout(true);
268 }
269
270 void SliderThumbElement::defaultEventHandler(Event* event)
271 {
272     if (!event->isMouseEvent()) {
273         HTMLDivElement::defaultEventHandler(event);
274         return;
275     }
276
277     // FIXME: Should handle this readonly/disabled check in more general way.
278     // Missing this kind of check is likely to occur elsewhere if adding it in each shadow element.
279     HTMLInputElement* input = hostInput();
280     if (!input || input->isReadOnlyFormControl() || !input->isEnabledFormControl()) {
281         stopDragging();
282         HTMLDivElement::defaultEventHandler(event);
283         return;
284     }
285
286     MouseEvent* mouseEvent = static_cast<MouseEvent*>(event);
287     bool isLeftButton = mouseEvent->button() == LeftButton;
288     const AtomicString& eventType = event->type();
289
290     // We intentionally do not call event->setDefaultHandled() here because
291     // MediaControlTimelineElement::defaultEventHandler() wants to handle these
292     // mouse events.
293     if (eventType == eventNames().mousedownEvent && isLeftButton) {
294         startDragging();
295         return;
296     } else if (eventType == eventNames().mouseupEvent && isLeftButton) {
297         stopDragging();
298         return;
299     } else if (eventType == eventNames().mousemoveEvent) {
300         if (m_inDragMode)
301             setPositionFromPoint(mouseEvent->absoluteLocation());
302         return;
303     }
304
305     HTMLDivElement::defaultEventHandler(event);
306 }
307
308 void SliderThumbElement::detach()
309 {
310     if (m_inDragMode) {
311         if (Frame* frame = document()->frame())
312             frame->eventHandler()->setCapturingMouseEventsNode(0);
313     }
314     HTMLDivElement::detach();
315 }
316
317 HTMLInputElement* SliderThumbElement::hostInput() const
318 {
319     // Only HTMLInputElement creates SliderThumbElement instances as its shadow nodes.
320     // So, shadowAncestorNode() must be an HTMLInputElement.
321     return shadowAncestorNode()->toInputElement();
322 }
323
324 const AtomicString& SliderThumbElement::shadowPseudoId() const
325 {
326     DEFINE_STATIC_LOCAL(AtomicString, sliderThumb, ("-webkit-slider-thumb"));
327     return sliderThumb;
328 }
329
330 // --------------------------------
331
332 inline TrackLimiterElement::TrackLimiterElement(Document* document)
333     : HTMLDivElement(HTMLNames::divTag, document)
334 {
335 }
336
337 PassRefPtr<TrackLimiterElement> TrackLimiterElement::create(Document* document)
338 {
339     RefPtr<TrackLimiterElement> element = adoptRef(new TrackLimiterElement(document));
340
341     element->setInlineStyleProperty(CSSPropertyVisibility, CSSValueHidden);
342     element->setInlineStyleProperty(CSSPropertyPosition, CSSValueStatic);
343
344     return element.release();
345 }
346
347 RenderObject* TrackLimiterElement::createRenderer(RenderArena* arena, RenderStyle*)
348 {
349     return new (arena) RenderSliderThumb(this);
350 }
351
352 const AtomicString& TrackLimiterElement::shadowPseudoId() const
353 {
354     DEFINE_STATIC_LOCAL(AtomicString, sliderThumb, ("-webkit-slider-thumb"));
355     return sliderThumb;
356 }
357
358 TrackLimiterElement* trackLimiterElementOf(Node* node)
359 {
360     ASSERT(node);
361     ASSERT(node->toInputElement()->shadow());
362     ShadowRoot* shadow = node->toInputElement()->shadow()->oldestShadowRoot();
363     ASSERT(shadow);
364     Node* limiter = shadow->firstChild()->lastChild();
365     ASSERT(limiter);
366     return static_cast<TrackLimiterElement*>(limiter);
367 }
368
369 // --------------------------------
370
371 inline SliderContainerElement::SliderContainerElement(Document* document)
372     : HTMLDivElement(HTMLNames::divTag, document)
373 {
374 }
375
376 PassRefPtr<SliderContainerElement> SliderContainerElement::create(Document* document)
377 {
378     return adoptRef(new SliderContainerElement(document));
379 }
380
381 RenderObject* SliderContainerElement::createRenderer(RenderArena* arena, RenderStyle*)
382 {
383     return new (arena) RenderSliderContainer(this);
384 }
385
386 const AtomicString& SliderContainerElement::shadowPseudoId() const
387 {
388     DEFINE_STATIC_LOCAL(AtomicString, sliderThumb, ("-webkit-slider-container"));
389     return sliderThumb;
390 }
391
392 }