a63fbe7e06ea6900decc5eee73127808c53de341
[WebKit-https.git] / Source / WebCore / rendering / RenderListBox.cpp
1 /*
2  * Copyright (C) 2006, 2007, 2008, 2011, 2014-2015 Apple Inc. All rights reserved.
3  *               2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  *
9  * 1.  Redistributions of source code must retain the above copyright
10  *     notice, this list of conditions and the following disclaimer. 
11  * 2.  Redistributions in binary form must reproduce the above copyright
12  *     notice, this list of conditions and the following disclaimer in the
13  *     documentation and/or other materials provided with the distribution. 
14  * 3.  Neither the name of Apple Inc. ("Apple") nor the names of
15  *     its contributors may be used to endorse or promote products derived
16  *     from this software without specific prior written permission. 
17  *
18  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
19  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
20  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
21  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
22  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
23  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
24  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
25  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28  */
29
30 #include "config.h"
31 #include "RenderListBox.h"
32
33 #include "AXObjectCache.h"
34 #include "CSSFontSelector.h"
35 #include "DeprecatedGlobalSettings.h"
36 #include "Document.h"
37 #include "DocumentEventQueue.h"
38 #include "EventHandler.h"
39 #include "FocusController.h"
40 #include "Frame.h"
41 #include "FrameSelection.h"
42 #include "FrameView.h"
43 #include "GraphicsContext.h"
44 #include "HTMLNames.h"
45 #include "HTMLOptionElement.h"
46 #include "HTMLOptGroupElement.h"
47 #include "HTMLSelectElement.h"
48 #include "HitTestResult.h"
49 #include "LayoutState.h"
50 #include "NodeRenderStyle.h"
51 #include "Page.h"
52 #include "PaintInfo.h"
53 #include "RenderLayer.h"
54 #include "RenderScrollbar.h"
55 #include "RenderText.h"
56 #include "RenderTheme.h"
57 #include "RenderView.h"
58 #include "ScrollAnimator.h"
59 #include "Scrollbar.h"
60 #include "ScrollbarTheme.h"
61 #include "Settings.h"
62 #include "SpatialNavigation.h"
63 #include "StyleResolver.h"
64 #include "StyleTreeResolver.h"
65 #include "WheelEventTestTrigger.h"
66 #include <math.h>
67 #include <wtf/IsoMallocInlines.h>
68 #include <wtf/StackStats.h>
69
70 namespace WebCore {
71
72 using namespace HTMLNames;
73
74 WTF_MAKE_ISO_ALLOCATED_IMPL(RenderListBox);
75  
76 const int rowSpacing = 1;
77
78 const int optionsSpacingHorizontal = 2;
79
80 // The minSize constant was originally defined to render scrollbars correctly.
81 // This might vary for different platforms.
82 const int minSize = 4;
83
84 // Default size when the multiple attribute is present but size attribute is absent.
85 const int defaultSize = 4;
86
87 // FIXME: This hardcoded baselineAdjustment is what we used to do for the old
88 // widget, but I'm not sure this is right for the new control.
89 const int baselineAdjustment = 7;
90
91 RenderListBox::RenderListBox(HTMLSelectElement& element, RenderStyle&& style)
92     : RenderBlockFlow(element, WTFMove(style))
93     , m_optionsChanged(true)
94     , m_scrollToRevealSelectionAfterLayout(false)
95     , m_inAutoscroll(false)
96     , m_optionsWidth(0)
97     , m_indexOffset(0)
98 {
99     view().frameView().addScrollableArea(this);
100 }
101
102 RenderListBox::~RenderListBox()
103 {
104     // Do not add any code here. Add it to willBeDestroyed() instead.
105 }
106
107 void RenderListBox::willBeDestroyed()
108 {
109     setHasVerticalScrollbar(false);
110     view().frameView().removeScrollableArea(this);
111     RenderBlockFlow::willBeDestroyed();
112 }
113
114 HTMLSelectElement& RenderListBox::selectElement() const
115 {
116     return downcast<HTMLSelectElement>(nodeForNonAnonymous());
117 }
118
119 static FontCascade bolder(Document& document, const FontCascade& font)
120 {
121     auto description = font.fontDescription();
122     description.setWeight(description.bolderWeight());
123     auto result = FontCascade { description, font.letterSpacing(), font.wordSpacing() };
124     result.update(&document.fontSelector());
125     return result;
126 }
127
128 void RenderListBox::updateFromElement()
129 {
130     if (m_optionsChanged) {
131         float width = 0;
132         auto& normalFont = style().fontCascade();
133         std::optional<FontCascade> boldFont;
134         for (auto* element : selectElement().listItems()) {
135             String text;
136             WTF::Function<const FontCascade&()> selectFont = [&normalFont] () -> const FontCascade& {
137                 return normalFont;
138             };
139             if (is<HTMLOptionElement>(*element))
140                 text = downcast<HTMLOptionElement>(*element).textIndentedToRespectGroupLabel();
141             else if (is<HTMLOptGroupElement>(*element)) {
142                 text = downcast<HTMLOptGroupElement>(*element).groupLabelText();
143                 selectFont = [this, &normalFont, &boldFont] () -> const FontCascade& {
144                     if (!boldFont)
145                         boldFont = bolder(document(), normalFont);
146                     return boldFont.value();
147                 };
148             }
149             if (text.isEmpty())
150                 continue;
151             text = applyTextTransform(style(), text, ' ');
152             auto textRun = constructTextRun(text, style(), AllowTrailingExpansion);
153             width = std::max(width, selectFont().width(textRun));
154         }
155         // FIXME: Is ceiling right here, or should we be doing some kind of rounding instead?
156         m_optionsWidth = static_cast<int>(std::ceil(width));
157         m_optionsChanged = false;
158
159         setHasVerticalScrollbar(true);
160
161         computeFirstIndexesVisibleInPaddingTopBottomAreas();
162
163         setNeedsLayoutAndPrefWidthsRecalc();
164     }
165 }
166
167 void RenderListBox::selectionChanged()
168 {
169     repaint();
170     if (!m_inAutoscroll) {
171         if (m_optionsChanged || needsLayout())
172             m_scrollToRevealSelectionAfterLayout = true;
173         else
174             scrollToRevealSelection();
175     }
176     
177     if (AXObjectCache* cache = document().existingAXObjectCache())
178         cache->deferSelectedChildrenChangedIfNeeded(selectElement());
179 }
180
181 void RenderListBox::layout()
182 {
183     StackStats::LayoutCheckPoint layoutCheckPoint;
184     RenderBlockFlow::layout();
185
186     if (m_vBar) {
187         bool enabled = numVisibleItems() < numItems();
188         m_vBar->setEnabled(enabled);
189         m_vBar->setSteps(1, std::max(1, numVisibleItems() - 1), itemHeight());
190         m_vBar->setProportion(numVisibleItems(), numItems());
191         if (!enabled) {
192             scrollToOffsetWithoutAnimation(VerticalScrollbar, 0);
193             m_indexOffset = 0;
194         }
195     }
196
197     if (m_scrollToRevealSelectionAfterLayout) {
198         LayoutStateDisabler layoutStateDisabler(view().frameView().layoutContext());
199         scrollToRevealSelection();
200     }
201 }
202
203 void RenderListBox::scrollToRevealSelection()
204 {    
205     m_scrollToRevealSelectionAfterLayout = false;
206
207     int firstIndex = selectElement().activeSelectionStartListIndex();
208     if (firstIndex >= 0 && !listIndexIsVisible(selectElement().activeSelectionEndListIndex()))
209         scrollToRevealElementAtListIndex(firstIndex);
210 }
211
212 void RenderListBox::computeIntrinsicLogicalWidths(LayoutUnit& minLogicalWidth, LayoutUnit& maxLogicalWidth) const
213 {
214     maxLogicalWidth = m_optionsWidth + 2 * optionsSpacingHorizontal;
215     if (m_vBar)
216         maxLogicalWidth += m_vBar->width();
217     if (!style().width().isPercentOrCalculated())
218         minLogicalWidth = maxLogicalWidth;
219 }
220
221 void RenderListBox::computePreferredLogicalWidths()
222 {
223     // Nested style recal do not fire post recal callbacks. see webkit.org/b/153767
224     ASSERT(!m_optionsChanged || Style::postResolutionCallbacksAreSuspended());
225
226     m_minPreferredLogicalWidth = 0;
227     m_maxPreferredLogicalWidth = 0;
228
229     if (style().width().isFixed() && style().width().value() > 0)
230         m_minPreferredLogicalWidth = m_maxPreferredLogicalWidth = adjustContentBoxLogicalWidthForBoxSizing(style().width().value());
231     else
232         computeIntrinsicLogicalWidths(m_minPreferredLogicalWidth, m_maxPreferredLogicalWidth);
233
234     if (style().minWidth().isFixed() && style().minWidth().value() > 0) {
235         m_maxPreferredLogicalWidth = std::max(m_maxPreferredLogicalWidth, adjustContentBoxLogicalWidthForBoxSizing(style().minWidth().value()));
236         m_minPreferredLogicalWidth = std::max(m_minPreferredLogicalWidth, adjustContentBoxLogicalWidthForBoxSizing(style().minWidth().value()));
237     }
238
239     if (style().maxWidth().isFixed()) {
240         m_maxPreferredLogicalWidth = std::min(m_maxPreferredLogicalWidth, adjustContentBoxLogicalWidthForBoxSizing(style().maxWidth().value()));
241         m_minPreferredLogicalWidth = std::min(m_minPreferredLogicalWidth, adjustContentBoxLogicalWidthForBoxSizing(style().maxWidth().value()));
242     }
243
244     LayoutUnit toAdd = horizontalBorderAndPaddingExtent();
245     m_minPreferredLogicalWidth += toAdd;
246     m_maxPreferredLogicalWidth += toAdd;
247                                 
248     setPreferredLogicalWidthsDirty(false);
249 }
250
251 int RenderListBox::size() const
252 {
253     int specifiedSize = selectElement().size();
254     if (specifiedSize > 1)
255         return std::max(minSize, specifiedSize);
256
257     return defaultSize;
258 }
259
260 int RenderListBox::numVisibleItems(ConsiderPadding considerPadding) const
261 {
262     // Only count fully visible rows. But don't return 0 even if only part of a row shows.
263     int visibleItemsExcludingPadding = std::max<int>(1, (contentHeight() + rowSpacing) / itemHeight());
264     if (considerPadding == ConsiderPadding::No)
265         return visibleItemsExcludingPadding;
266
267     return numberOfVisibleItemsInPaddingTop() + visibleItemsExcludingPadding + numberOfVisibleItemsInPaddingBottom();
268 }
269
270 int RenderListBox::numItems() const
271 {
272     return selectElement().listItems().size();
273 }
274
275 LayoutUnit RenderListBox::listHeight() const
276 {
277     return itemHeight() * numItems() - rowSpacing;
278 }
279
280 RenderBox::LogicalExtentComputedValues RenderListBox::computeLogicalHeight(LayoutUnit, LayoutUnit logicalTop) const
281 {
282     LayoutUnit height = itemHeight() * size() - rowSpacing;
283     cacheIntrinsicContentLogicalHeightForFlexItem(height);
284     height += verticalBorderAndPaddingExtent();
285     return RenderBox::computeLogicalHeight(height, logicalTop);
286 }
287
288 int RenderListBox::baselinePosition(FontBaseline baselineType, bool firstLine, LineDirectionMode lineDirection, LinePositionMode linePositionMode) const
289 {
290     return RenderBox::baselinePosition(baselineType, firstLine, lineDirection, linePositionMode) - baselineAdjustment;
291 }
292
293 LayoutRect RenderListBox::itemBoundingBoxRect(const LayoutPoint& additionalOffset, int index)
294 {
295     LayoutUnit x = additionalOffset.x() + borderLeft() + paddingLeft();
296     if (shouldPlaceBlockDirectionScrollbarOnLeft() && m_vBar)
297         x += m_vBar->occupiedWidth();
298     LayoutUnit y = additionalOffset.y() + borderTop() + paddingTop() + itemHeight() * (index - m_indexOffset);
299     return LayoutRect(x, y, contentWidth(), itemHeight());
300 }
301
302 void RenderListBox::paintItem(PaintInfo& paintInfo, const LayoutPoint& paintOffset, const PaintFunction& paintFunction)
303 {
304     int listItemsSize = numItems();
305     int firstVisibleItem = m_indexOfFirstVisibleItemInsidePaddingTopArea.value_or(m_indexOffset);
306     int endIndex = firstVisibleItem + numVisibleItems(ConsiderPadding::Yes);
307     for (int i = firstVisibleItem; i < listItemsSize && i < endIndex; ++i)
308         paintFunction(paintInfo, paintOffset, i);
309 }
310
311 void RenderListBox::paintObject(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
312 {
313     if (style().visibility() != VISIBLE)
314         return;
315     
316     if (paintInfo.phase == PaintPhaseForeground) {
317         paintItem(paintInfo, paintOffset, [this](PaintInfo& paintInfo, const LayoutPoint& paintOffset, int listItemIndex) {
318             paintItemForeground(paintInfo, paintOffset, listItemIndex);
319         });
320     }
321
322     // Paint the children.
323     RenderBlockFlow::paintObject(paintInfo, paintOffset);
324
325     switch (paintInfo.phase) {
326     // Depending on whether we have overlay scrollbars they
327     // get rendered in the foreground or background phases
328     case PaintPhaseForeground:
329         if (m_vBar->isOverlayScrollbar())
330             paintScrollbar(paintInfo, paintOffset);
331         break;
332     case PaintPhaseBlockBackground:
333         if (!m_vBar->isOverlayScrollbar())
334             paintScrollbar(paintInfo, paintOffset);
335         break;
336     case PaintPhaseChildBlockBackground:
337     case PaintPhaseChildBlockBackgrounds: {
338         paintItem(paintInfo, paintOffset, [this](PaintInfo& paintInfo, const LayoutPoint& paintOffset, int listItemIndex) {
339             paintItemBackground(paintInfo, paintOffset, listItemIndex);
340         });
341         break;
342     }
343     default:
344         break;
345     }
346 }
347
348 void RenderListBox::addFocusRingRects(Vector<LayoutRect>& rects, const LayoutPoint& additionalOffset, const RenderLayerModelObject* paintContainer)
349 {
350     if (!selectElement().allowsNonContiguousSelection())
351         return RenderBlockFlow::addFocusRingRects(rects, additionalOffset, paintContainer);
352
353     // Focus the last selected item.
354     int selectedItem = selectElement().activeSelectionEndListIndex();
355     if (selectedItem >= 0) {
356         rects.append(snappedIntRect(itemBoundingBoxRect(additionalOffset, selectedItem)));
357         return;
358     }
359
360     // No selected items, find the first non-disabled item.
361     int size = numItems();
362     const Vector<HTMLElement*>& listItems = selectElement().listItems();
363     for (int i = 0; i < size; ++i) {
364         HTMLElement* element = listItems[i];
365         if (is<HTMLOptionElement>(*element) && !element->isDisabledFormControl()) {
366             selectElement().setActiveSelectionEndIndex(i);
367             rects.append(itemBoundingBoxRect(additionalOffset, i));
368             return;
369         }
370     }
371 }
372
373 void RenderListBox::paintScrollbar(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
374 {
375     if (!m_vBar)
376         return;
377
378     LayoutUnit left = paintOffset.x() + (shouldPlaceBlockDirectionScrollbarOnLeft() ? borderLeft() : width() - borderRight() - m_vBar->width());
379     LayoutUnit top = paintOffset.y() + borderTop();
380     LayoutUnit width = m_vBar->width();
381     LayoutUnit height = this->height() - (borderTop() + borderBottom());
382     IntRect scrollRect = snappedIntRect(left, top, width, height);
383     m_vBar->setFrameRect(scrollRect);
384     m_vBar->paint(paintInfo.context(), snappedIntRect(paintInfo.rect));
385 }
386
387 static LayoutSize itemOffsetForAlignment(TextRun textRun, const RenderStyle* itemStyle, FontCascade itemFont, LayoutRect itemBoudingBox)
388 {
389     ETextAlign actualAlignment = itemStyle->textAlign();
390     // FIXME: Firefox doesn't respect JUSTIFY. Should we?
391     // FIXME: Handle TAEND here
392     if (actualAlignment == TASTART || actualAlignment == JUSTIFY)
393       actualAlignment = itemStyle->isLeftToRightDirection() ? LEFT : RIGHT;
394
395     LayoutSize offset = LayoutSize(0, itemFont.fontMetrics().ascent());
396     if (actualAlignment == RIGHT || actualAlignment == WEBKIT_RIGHT) {
397         float textWidth = itemFont.width(textRun);
398         offset.setWidth(itemBoudingBox.width() - textWidth - optionsSpacingHorizontal);
399     } else if (actualAlignment == CENTER || actualAlignment == WEBKIT_CENTER) {
400         float textWidth = itemFont.width(textRun);
401         offset.setWidth((itemBoudingBox.width() - textWidth) / 2);
402     } else
403         offset.setWidth(optionsSpacingHorizontal);
404     return offset;
405 }
406
407 void RenderListBox::paintItemForeground(PaintInfo& paintInfo, const LayoutPoint& paintOffset, int listIndex)
408 {
409     const Vector<HTMLElement*>& listItems = selectElement().listItems();
410     HTMLElement* listItemElement = listItems[listIndex];
411
412     auto& itemStyle = *listItemElement->computedStyle();
413
414     if (itemStyle.visibility() == HIDDEN)
415         return;
416
417     String itemText;
418     bool isOptionElement = is<HTMLOptionElement>(*listItemElement);
419     if (isOptionElement)
420         itemText = downcast<HTMLOptionElement>(*listItemElement).textIndentedToRespectGroupLabel();
421     else if (is<HTMLOptGroupElement>(*listItemElement))
422         itemText = downcast<HTMLOptGroupElement>(*listItemElement).groupLabelText();
423     itemText = applyTextTransform(style(), itemText, ' ');
424
425     Color textColor = itemStyle.visitedDependentColor(CSSPropertyColor);
426     if (isOptionElement && downcast<HTMLOptionElement>(*listItemElement).selected()) {
427         if (frame().selection().isFocusedAndActive() && document().focusedElement() == &selectElement())
428             textColor = theme().activeListBoxSelectionForegroundColor();
429         // Honor the foreground color for disabled items
430         else if (!listItemElement->isDisabledFormControl() && !selectElement().isDisabledFormControl())
431             textColor = theme().inactiveListBoxSelectionForegroundColor();
432     }
433
434     paintInfo.context().setFillColor(textColor);
435
436     TextRun textRun(itemText, 0, 0, AllowTrailingExpansion, itemStyle.direction(), isOverride(itemStyle.unicodeBidi()), true);
437     FontCascade itemFont = style().fontCascade();
438     LayoutRect r = itemBoundingBoxRect(paintOffset, listIndex);
439     r.move(itemOffsetForAlignment(textRun, &itemStyle, itemFont, r));
440
441     if (is<HTMLOptGroupElement>(*listItemElement)) {
442         auto description = itemFont.fontDescription();
443         description.setWeight(description.bolderWeight());
444         itemFont = FontCascade(description, itemFont.letterSpacing(), itemFont.wordSpacing());
445         itemFont.update(&document().fontSelector());
446     }
447
448     // Draw the item text
449     paintInfo.context().drawBidiText(itemFont, textRun, roundedIntPoint(r.location()));
450 }
451
452 void RenderListBox::paintItemBackground(PaintInfo& paintInfo, const LayoutPoint& paintOffset, int listIndex)
453 {
454     const Vector<HTMLElement*>& listItems = selectElement().listItems();
455     HTMLElement* listItemElement = listItems[listIndex];
456     auto& itemStyle = *listItemElement->computedStyle();
457
458     Color backColor;
459     if (is<HTMLOptionElement>(*listItemElement) && downcast<HTMLOptionElement>(*listItemElement).selected()) {
460         if (frame().selection().isFocusedAndActive() && document().focusedElement() == &selectElement())
461             backColor = theme().activeListBoxSelectionBackgroundColor();
462         else
463             backColor = theme().inactiveListBoxSelectionBackgroundColor(document().useSystemAppearance());
464     } else
465         backColor = itemStyle.visitedDependentColor(CSSPropertyBackgroundColor);
466
467     // Draw the background for this list box item
468     if (itemStyle.visibility() == HIDDEN)
469         return;
470
471     LayoutRect itemRect = itemBoundingBoxRect(paintOffset, listIndex);
472     itemRect.intersect(controlClipRect(paintOffset));
473     paintInfo.context().fillRect(snappedIntRect(itemRect), backColor);
474 }
475
476 bool RenderListBox::isPointInOverflowControl(HitTestResult& result, const LayoutPoint& locationInContainer, const LayoutPoint& accumulatedOffset)
477 {
478     if (!m_vBar || !m_vBar->shouldParticipateInHitTesting())
479         return false;
480
481     LayoutUnit x = accumulatedOffset.x() + (shouldPlaceBlockDirectionScrollbarOnLeft() ? borderLeft() : width() - borderRight() - m_vBar->width());
482     LayoutUnit y = accumulatedOffset.y() + borderTop();
483     LayoutUnit width = m_vBar->width();
484     LayoutUnit height = this->height() - borderTop() - borderBottom();
485     LayoutRect vertRect(x, y, width, height);
486
487     if (!vertRect.contains(locationInContainer))
488         return false;
489
490     result.setScrollbar(m_vBar.get());
491     return true;
492 }
493
494 int RenderListBox::listIndexAtOffset(const LayoutSize& offset)
495 {
496     if (!numItems())
497         return -1;
498
499     if (offset.height() < borderTop() || offset.height() > height() - borderBottom())
500         return -1;
501
502     int scrollbarWidth = m_vBar ? m_vBar->width() : 0;
503     if (shouldPlaceBlockDirectionScrollbarOnLeft() && (offset.width() < borderLeft() + paddingLeft() + scrollbarWidth || offset.width() > width() - borderRight() - paddingRight()))
504         return -1;
505     if (!shouldPlaceBlockDirectionScrollbarOnLeft() && (offset.width() < borderLeft() + paddingLeft() || offset.width() > width() - borderRight() - paddingRight() - scrollbarWidth))
506         return -1;
507
508     int newOffset = (offset.height() - borderTop() - paddingTop()) / itemHeight() + m_indexOffset;
509     return newOffset < numItems() ? newOffset : -1;
510 }
511
512 void RenderListBox::panScroll(const IntPoint& panStartMousePosition)
513 {
514     const int maxSpeed = 20;
515     const int iconRadius = 7;
516     const int speedReducer = 4;
517
518     // FIXME: This doesn't work correctly with transforms.
519     FloatPoint absOffset = localToAbsolute();
520
521     IntPoint lastKnownMousePosition = frame().eventHandler().lastKnownMousePosition();
522     // We need to check if the last known mouse position is out of the window. When the mouse is out of the window, the position is incoherent
523     static IntPoint previousMousePosition;
524     if (lastKnownMousePosition.y() < 0)
525         lastKnownMousePosition = previousMousePosition;
526     else
527         previousMousePosition = lastKnownMousePosition;
528
529     int yDelta = lastKnownMousePosition.y() - panStartMousePosition.y();
530
531     // If the point is too far from the center we limit the speed
532     yDelta = std::max<int>(std::min<int>(yDelta, maxSpeed), -maxSpeed);
533     
534     if (abs(yDelta) < iconRadius) // at the center we let the space for the icon
535         return;
536
537     if (yDelta > 0)
538         //offsetY = view()->viewHeight();
539         absOffset.move(0, listHeight());
540     else if (yDelta < 0)
541         yDelta--;
542
543     // Let's attenuate the speed
544     yDelta /= speedReducer;
545
546     IntPoint scrollPoint(0, 0);
547     scrollPoint.setY(absOffset.y() + yDelta);
548     int newOffset = scrollToward(scrollPoint);
549     if (newOffset < 0) 
550         return;
551
552     m_inAutoscroll = true;
553     selectElement().updateListBoxSelection(!selectElement().multiple());
554     m_inAutoscroll = false;
555 }
556
557 int RenderListBox::scrollToward(const IntPoint& destination)
558 {
559     // FIXME: This doesn't work correctly with transforms.
560     FloatPoint absPos = localToAbsolute();
561     IntSize positionOffset = roundedIntSize(destination - absPos);
562
563     int rows = numVisibleItems();
564     int offset = m_indexOffset;
565     
566     if (positionOffset.height() < borderTop() + paddingTop() && scrollToRevealElementAtListIndex(offset - 1))
567         return offset - 1;
568     
569     if (positionOffset.height() > height() - paddingBottom() - borderBottom() && scrollToRevealElementAtListIndex(offset + rows))
570         return offset + rows - 1;
571     
572     return listIndexAtOffset(positionOffset);
573 }
574
575 void RenderListBox::autoscroll(const IntPoint&)
576 {
577     IntPoint pos = frame().view()->windowToContents(frame().eventHandler().lastKnownMousePosition());
578
579     int endIndex = scrollToward(pos);
580     if (selectElement().isDisabledFormControl())
581         return;
582
583     if (endIndex >= 0) {
584         m_inAutoscroll = true;
585
586         if (!selectElement().multiple())
587             selectElement().setActiveSelectionAnchorIndex(endIndex);
588
589         selectElement().setActiveSelectionEndIndex(endIndex);
590         selectElement().updateListBoxSelection(!selectElement().multiple());
591         m_inAutoscroll = false;
592     }
593 }
594
595 void RenderListBox::stopAutoscroll()
596 {
597     if (selectElement().isDisabledFormControl())
598         return;
599
600     selectElement().listBoxOnChange();
601 }
602
603 bool RenderListBox::scrollToRevealElementAtListIndex(int index)
604 {
605     if (index < 0 || index >= numItems() || listIndexIsVisible(index))
606         return false;
607
608     int newOffset;
609     if (index < m_indexOffset)
610         newOffset = index;
611     else
612         newOffset = index - numVisibleItems() + 1;
613
614     scrollToOffsetWithoutAnimation(VerticalScrollbar, newOffset);
615
616     return true;
617 }
618
619 bool RenderListBox::listIndexIsVisible(int index)
620 {
621     int firstIndex = m_indexOfFirstVisibleItemInsidePaddingTopArea.value_or(m_indexOffset);
622     int endIndex = m_indexOfFirstVisibleItemInsidePaddingBottomArea
623         ? m_indexOfFirstVisibleItemInsidePaddingBottomArea.value() + numberOfVisibleItemsInPaddingBottom()
624         : m_indexOffset + numVisibleItems();
625
626     return index >= firstIndex && index < endIndex;
627 }
628
629 bool RenderListBox::scroll(ScrollDirection direction, ScrollGranularity granularity, float multiplier, Element**, RenderBox*, const IntPoint&)
630 {
631     return ScrollableArea::scroll(direction, granularity, multiplier);
632 }
633
634 bool RenderListBox::logicalScroll(ScrollLogicalDirection direction, ScrollGranularity granularity, float multiplier, Element**)
635 {
636     return ScrollableArea::scroll(logicalToPhysical(direction, style().isHorizontalWritingMode(), style().isFlippedBlocksWritingMode()), granularity, multiplier);
637 }
638
639 void RenderListBox::valueChanged(unsigned listIndex)
640 {
641     selectElement().setSelectedIndex(selectElement().listToOptionIndex(listIndex));
642     selectElement().dispatchFormControlChangeEvent();
643 }
644
645 int RenderListBox::scrollSize(ScrollbarOrientation orientation) const
646 {
647     return ((orientation == VerticalScrollbar) && m_vBar) ? (m_vBar->totalSize() - m_vBar->visibleSize()) : 0;
648 }
649
650 int RenderListBox::scrollOffset(ScrollbarOrientation) const
651 {
652     return m_indexOffset;
653 }
654
655 ScrollPosition RenderListBox::minimumScrollPosition() const
656 {
657     return { 0, 0 };
658 }
659
660 ScrollPosition RenderListBox::maximumScrollPosition() const
661 {
662     return { 0, numItems() - numVisibleItems() };
663 }
664
665 void RenderListBox::setScrollOffset(const ScrollOffset& offset)
666 {
667     scrollTo(offset.y());
668 }
669
670 int RenderListBox::maximumNumberOfItemsThatFitInPaddingBottomArea() const
671 {
672     return paddingBottom() / itemHeight();
673 }
674
675 int RenderListBox::numberOfVisibleItemsInPaddingTop() const
676 {
677     if (!m_indexOfFirstVisibleItemInsidePaddingTopArea)
678         return 0;
679
680     return m_indexOffset - m_indexOfFirstVisibleItemInsidePaddingTopArea.value();
681 }
682
683 int RenderListBox::numberOfVisibleItemsInPaddingBottom() const
684 {
685     if (!m_indexOfFirstVisibleItemInsidePaddingBottomArea)
686         return 0;
687
688     return std::min(maximumNumberOfItemsThatFitInPaddingBottomArea(), numItems() - m_indexOffset - numVisibleItems());
689 }
690
691 void RenderListBox::computeFirstIndexesVisibleInPaddingTopBottomAreas()
692 {
693     m_indexOfFirstVisibleItemInsidePaddingTopArea = std::nullopt;
694     m_indexOfFirstVisibleItemInsidePaddingBottomArea = std::nullopt;
695
696     int maximumNumberOfItemsThatFitInPaddingTopArea = paddingTop() / itemHeight();
697     if (maximumNumberOfItemsThatFitInPaddingTopArea) {
698         if (m_indexOffset)
699             m_indexOfFirstVisibleItemInsidePaddingTopArea = std::max(0, m_indexOffset - maximumNumberOfItemsThatFitInPaddingTopArea);
700     }
701
702     if (maximumNumberOfItemsThatFitInPaddingBottomArea()) {
703         if (numItems() > (m_indexOffset + numVisibleItems()))
704             m_indexOfFirstVisibleItemInsidePaddingBottomArea = m_indexOffset + numVisibleItems();
705     }
706 }
707
708 void RenderListBox::scrollTo(int newOffset)
709 {
710     if (newOffset == m_indexOffset)
711         return;
712
713     m_indexOffset = newOffset;
714
715     computeFirstIndexesVisibleInPaddingTopBottomAreas();
716
717     repaint();
718     document().eventQueue().enqueueOrDispatchScrollEvent(selectElement());
719 }
720
721 LayoutUnit RenderListBox::itemHeight() const
722 {
723     return style().fontMetrics().height() + rowSpacing;
724 }
725
726 int RenderListBox::verticalScrollbarWidth() const
727 {
728     return m_vBar ? m_vBar->occupiedWidth() : 0;
729 }
730
731 // FIXME: We ignore padding in the vertical direction as far as these values are concerned, since that's
732 // how the control currently paints.
733 int RenderListBox::scrollWidth() const
734 {
735     // There is no horizontal scrolling allowed.
736     return roundToInt(clientWidth());
737 }
738
739 int RenderListBox::scrollHeight() const
740 {
741     return roundToInt(std::max(clientHeight(), listHeight()));
742 }
743
744 int RenderListBox::scrollLeft() const
745 {
746     return 0;
747 }
748
749 void RenderListBox::setScrollLeft(int, ScrollClamping)
750 {
751 }
752
753 int RenderListBox::scrollTop() const
754 {
755     return m_indexOffset * itemHeight();
756 }
757
758 static void setupWheelEventTestTrigger(RenderListBox& renderer)
759 {
760     if (!renderer.page().expectsWheelEventTriggers())
761         return;
762
763     renderer.scrollAnimator().setWheelEventTestTrigger(renderer.page().testTrigger());
764 }
765
766 void RenderListBox::setScrollTop(int newTop, ScrollClamping)
767 {
768     // Determine an index and scroll to it.    
769     int index = newTop / itemHeight();
770     if (index < 0 || index >= numItems() || index == m_indexOffset)
771         return;
772     setupWheelEventTestTrigger(*this);
773     scrollToOffsetWithoutAnimation(VerticalScrollbar, index);
774 }
775
776 bool RenderListBox::nodeAtPoint(const HitTestRequest& request, HitTestResult& result, const HitTestLocation& locationInContainer, const LayoutPoint& accumulatedOffset, HitTestAction hitTestAction)
777 {
778     if (!RenderBlockFlow::nodeAtPoint(request, result, locationInContainer, accumulatedOffset, hitTestAction))
779         return false;
780     const Vector<HTMLElement*>& listItems = selectElement().listItems();
781     int size = numItems();
782     LayoutPoint adjustedLocation = accumulatedOffset + location();
783
784     for (int i = 0; i < size; ++i) {
785         if (!itemBoundingBoxRect(adjustedLocation, i).contains(locationInContainer.point()))
786             continue;
787         if (Element* node = listItems[i]) {
788             result.setInnerNode(node);
789             if (!result.innerNonSharedNode())
790                 result.setInnerNonSharedNode(node);
791             result.setLocalPoint(locationInContainer.point() - toLayoutSize(adjustedLocation));
792             break;
793         }
794     }
795
796     return true;
797 }
798
799 LayoutRect RenderListBox::controlClipRect(const LayoutPoint& additionalOffset) const
800 {
801     // Clip against the padding box, to give <option>s and overlay scrollbar some extra space
802     // to get painted.
803     LayoutRect clipRect = paddingBoxRect();
804     if (shouldPlaceBlockDirectionScrollbarOnLeft())
805         clipRect.move(m_vBar->occupiedWidth(), 0);
806     clipRect.moveBy(additionalOffset);
807     return clipRect;
808 }
809
810 bool RenderListBox::isActive() const
811 {
812     return page().focusController().isActive();
813 }
814
815 void RenderListBox::invalidateScrollbarRect(Scrollbar& scrollbar, const IntRect& rect)
816 {
817     IntRect scrollRect = rect;
818     scrollRect.move(shouldPlaceBlockDirectionScrollbarOnLeft() ? borderLeft() : width() - borderRight() - scrollbar.width(), borderTop());
819     repaintRectangle(scrollRect);
820 }
821
822 IntRect RenderListBox::convertFromScrollbarToContainingView(const Scrollbar& scrollbar, const IntRect& scrollbarRect) const
823 {
824     IntRect rect = scrollbarRect;
825     int scrollbarLeft = shouldPlaceBlockDirectionScrollbarOnLeft() ? borderLeft() : width() - borderRight() - scrollbar.width();
826     int scrollbarTop = borderTop();
827     rect.move(scrollbarLeft, scrollbarTop);
828     return view().frameView().convertFromRendererToContainingView(this, rect);
829 }
830
831 IntRect RenderListBox::convertFromContainingViewToScrollbar(const Scrollbar& scrollbar, const IntRect& parentRect) const
832 {
833     IntRect rect = view().frameView().convertFromContainingViewToRenderer(this, parentRect);
834     int scrollbarLeft = shouldPlaceBlockDirectionScrollbarOnLeft() ? borderLeft() : width() - borderRight() - scrollbar.width();
835     int scrollbarTop = borderTop();
836     rect.move(-scrollbarLeft, -scrollbarTop);
837     return rect;
838 }
839
840 IntPoint RenderListBox::convertFromScrollbarToContainingView(const Scrollbar& scrollbar, const IntPoint& scrollbarPoint) const
841 {
842     IntPoint point = scrollbarPoint;
843     int scrollbarLeft = shouldPlaceBlockDirectionScrollbarOnLeft() ? borderLeft() : width() - borderRight() - scrollbar.width();
844     int scrollbarTop = borderTop();
845     point.move(scrollbarLeft, scrollbarTop);
846     return view().frameView().convertFromRendererToContainingView(this, point);
847 }
848
849 IntPoint RenderListBox::convertFromContainingViewToScrollbar(const Scrollbar& scrollbar, const IntPoint& parentPoint) const
850 {
851     IntPoint point = view().frameView().convertFromContainingViewToRenderer(this, parentPoint);
852     int scrollbarLeft = shouldPlaceBlockDirectionScrollbarOnLeft() ? borderLeft() : width() - borderRight() - scrollbar.width();
853     int scrollbarTop = borderTop();
854     point.move(-scrollbarLeft, -scrollbarTop);
855     return point;
856 }
857
858 IntSize RenderListBox::contentsSize() const
859 {
860     return IntSize(scrollWidth(), scrollHeight());
861 }
862
863 IntPoint RenderListBox::lastKnownMousePosition() const
864 {
865     return view().frameView().lastKnownMousePosition();
866 }
867
868 bool RenderListBox::isHandlingWheelEvent() const
869 {
870     return view().frameView().isHandlingWheelEvent();
871 }
872
873 bool RenderListBox::shouldSuspendScrollAnimations() const
874 {
875     return view().frameView().shouldSuspendScrollAnimations();
876 }
877
878 bool RenderListBox::forceUpdateScrollbarsOnMainThreadForPerformanceTesting() const
879 {
880     return settings().forceUpdateScrollbarsOnMainThreadForPerformanceTesting();
881 }
882
883 ScrollableArea* RenderListBox::enclosingScrollableArea() const
884 {
885     // FIXME: Return a RenderLayer that's scrollable.
886     return nullptr;
887 }
888
889 bool RenderListBox::isScrollableOrRubberbandable()
890 {
891     return m_vBar;
892 }
893
894 bool RenderListBox::hasScrollableOrRubberbandableAncestor()
895 {
896     return enclosingLayer() && enclosingLayer()->hasScrollableOrRubberbandableAncestor();
897 }
898
899 IntRect RenderListBox::scrollableAreaBoundingBox(bool*) const
900 {
901     return absoluteBoundingBoxRect();
902 }
903
904 bool RenderListBox::usesMockScrollAnimator() const
905 {
906     return DeprecatedGlobalSettings::usesMockScrollAnimator();
907 }
908
909 void RenderListBox::logMockScrollAnimatorMessage(const String& message) const
910 {
911     document().addConsoleMessage(MessageSource::Other, MessageLevel::Debug, "RenderListBox: " + message);
912 }
913
914 Ref<Scrollbar> RenderListBox::createScrollbar()
915 {
916     RefPtr<Scrollbar> widget;
917     bool hasCustomScrollbarStyle = style().hasPseudoStyle(SCROLLBAR);
918     if (hasCustomScrollbarStyle)
919         widget = RenderScrollbar::createCustomScrollbar(*this, VerticalScrollbar, &selectElement());
920     else {
921         widget = Scrollbar::createNativeScrollbar(*this, VerticalScrollbar, theme().scrollbarControlSizeForPart(ListboxPart));
922         didAddScrollbar(widget.get(), VerticalScrollbar);
923         if (page().expectsWheelEventTriggers())
924             scrollAnimator().setWheelEventTestTrigger(page().testTrigger());
925     }
926     view().frameView().addChild(*widget);
927     return widget.releaseNonNull();
928 }
929
930 void RenderListBox::destroyScrollbar()
931 {
932     if (!m_vBar)
933         return;
934
935     if (!m_vBar->isCustomScrollbar())
936         ScrollableArea::willRemoveScrollbar(m_vBar.get(), VerticalScrollbar);
937     m_vBar->removeFromParent();
938     m_vBar = nullptr;
939 }
940
941 void RenderListBox::setHasVerticalScrollbar(bool hasScrollbar)
942 {
943     if (hasScrollbar == (m_vBar != nullptr))
944         return;
945
946     if (hasScrollbar)
947         m_vBar = createScrollbar();
948     else
949         destroyScrollbar();
950
951     if (m_vBar)
952         m_vBar->styleChanged();
953
954     // Force an update since we know the scrollbars have changed things.
955 #if ENABLE(DASHBOARD_SUPPORT)
956     if (document().hasAnnotatedRegions())
957         document().setAnnotatedRegionsDirty(true);
958 #endif
959 }
960
961 bool RenderListBox::scrolledToTop() const
962 {
963     if (Scrollbar* vbar = verticalScrollbar())
964     return vbar->value() <= 0;
965
966     return true;
967 }
968
969 bool RenderListBox::scrolledToBottom() const
970 {
971     Scrollbar* vbar = verticalScrollbar();
972     if (!vbar)
973         return true;
974
975     return vbar->value() >= vbar->maximum();
976 }
977
978 bool RenderListBox::scrolledToLeft() const
979 {
980     // We do not scroll horizontally in a select element, so always report
981     // that we are at the full extent of the scroll.
982     return true;
983 }
984
985 bool RenderListBox::scrolledToRight() const
986 {
987     // We do not scroll horizontally in a select element, so always report
988     // that we are at the full extent of the scroll.
989     return true;
990 }
991     
992 } // namespace WebCore