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