Making multiple select element RTL direction aware

Source/core/rendering/RenderListBox.cpp

 /*
  * Copyright (C) 2006, 2007, 2008, 2011 Apple Inc. All rights reserved.
  *               2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
@@ skipping 256 matching lines @@
     RenderBox::computeLogicalHeight(height, logicalTop, computedValues);
 }
 
 int RenderListBox::baselinePosition(FontBaseline baselineType, bool firstLine, LineDirectionMode lineDirection, LinePositionMode linePositionMode) const
 {
     return RenderBox::baselinePosition(baselineType, firstLine, lineDirection, linePositionMode) - baselineAdjustment;
 }
 
 LayoutRect RenderListBox::itemBoundingBoxRect(const LayoutPoint& additionalOffset, int index)
 {
-    return LayoutRect(additionalOffset.x() + borderLeft() + paddingLeft(),
+    // For RTL, items start after the left-side vertical scrollbar.
+    int scrollbarOffset = style()->shouldPlaceBlockDirectionScrollbarOnLogicalLeft() ? m_vBar->width() : 0;
+    return LayoutRect(additionalOffset.x() + borderLeft() + paddingLeft() + scrollbarOffset,
         additionalOffset.y() + borderTop() + paddingTop() + itemHeight() * (index - m_indexOffset),
         contentWidth(), itemHeight());
 }
 
 void RenderListBox::paintObject(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
     if (style()->visibility() != VISIBLE)
         return;
 
     int listItemsSize = numItems();
@@ skipping 53 matching lines @@
     const Vector<HTMLElement*>& listItems = select->listItems();
     for (int i = 0; i < size; ++i) {
         HTMLElement* element = listItems[i];
         if (element->hasTagName(optionTag) && !element->isDisabledFormControl()) {
             rects.append(pixelSnappedIntRect(itemBoundingBoxRect(additionalOffset, i)));
             return;
         }
     }
 }
 
+int RenderListBox::scrollbarLeft() const
+{
+    int scrollbarLeft = 0;
+    if (style()->shouldPlaceBlockDirectionScrollbarOnLogicalLeft())
+        scrollbarLeft = borderLeft();
+    else
+        scrollbarLeft = width() - borderRight() - m_vBar->width();
+    return scrollbarLeft;
+}
+
 void RenderListBox::paintScrollbar(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
     if (m_vBar) {
-        IntRect scrollRect = pixelSnappedIntRect(paintOffset.x() + width() - borderRight() - m_vBar->width(),
+        IntRect scrollRect = pixelSnappedIntRect(paintOffset.x() + scrollbarLeft(),
             paintOffset.y() + borderTop(),
             m_vBar->width(),
             height() - (borderTop() + borderBottom()));
         m_vBar->setFrameRect(scrollRect);
         m_vBar->paint(paintInfo.context, paintInfo.rect);
     }
 }
 
 static LayoutSize itemOffsetForAlignment(TextRun textRun, RenderStyle* itemStyle, Font itemFont, LayoutRect itemBoudingBox)
 {
@@ skipping 89 matching lines @@
         itemRect.intersect(controlClipRect(paintOffset));
         paintInfo.context->fillRect(pixelSnappedIntRect(itemRect), backColor);
     }
 }
 
 bool RenderListBox::isPointInOverflowControl(HitTestResult& result, const LayoutPoint& locationInContainer, const LayoutPoint& accumulatedOffset)
 {
     if (!m_vBar || !m_vBar->shouldParticipateInHitTesting())
         return false;
 
-    LayoutRect vertRect(accumulatedOffset.x() + width() - borderRight() - m_vBar->width(),
+    LayoutRect vertRect(accumulatedOffset.x() + scrollbarLeft(),
                         accumulatedOffset.y() + borderTop(),
                         m_vBar->width(),
                         height() - borderTop() - borderBottom());
 
     if (vertRect.contains(locationInContainer)) {
         result.setScrollbar(m_vBar.get());
         return true;
     }
     return false;
 }
 
 int RenderListBox::listIndexAtOffset(const LayoutSize& offset)
 {
     if (!numItems())
         return -1;
 
     if (offset.height() < borderTop() + paddingTop() || offset.height() > height() - paddingBottom() - borderBottom())
         return -1;
 
     int scrollbarWidth = m_vBar ? m_vBar->width() : 0;
-    if (offset.width() < borderLeft() + paddingLeft() || offset.width() > width() - borderRight() - paddingRight() - scrollbarWidth)
+    int rightScrollbarOffset = style()->shouldPlaceBlockDirectionScrollbarOnLogicalLeft() ? scrollbarWidth : 0;
+    int leftScrollbarOffset = style()->shouldPlaceBlockDirectionScrollbarOnLogicalLeft() ? 0 : scrollbarWidth;
+    if (offset.width() < borderLeft() + paddingLeft() + rightScrollbarOffset
+        || offset.width() > width() - borderRight() - paddingRight() - leftScrollbarOffset)
         return -1;
 
     int newOffset = (offset.height() - borderTop() - paddingTop()) / itemHeight() + m_indexOffset;
     return newOffset < numItems() ? newOffset : -1;
 }
 
 void RenderListBox::panScroll(const IntPoint& panStartMousePosition)
 {
     const int maxSpeed = 20;
     const int iconRadius = 7;
@@ skipping 210 matching lines @@
             }
         }
     }
 
     return true;
 }
 
 LayoutRect RenderListBox::controlClipRect(const LayoutPoint& additionalOffset) const
 {
     LayoutRect clipRect = contentBoxRect();
-    clipRect.moveBy(additionalOffset);
+    if (style()->shouldPlaceBlockDirectionScrollbarOnLogicalLeft())
+        clipRect.moveBy(additionalOffset + LayoutPoint(m_vBar->width(), 0));
+    else
+        clipRect.moveBy(additionalOffset);
     return clipRect;
 }
 
 bool RenderListBox::isActive() const
 {
     Page* page = frame()->page();
     return page && page->focusController().isActive();
 }
 
 void RenderListBox::invalidateScrollbarRect(Scrollbar* scrollbar, const IntRect& rect)
 {
     IntRect scrollRect = rect;
-    scrollRect.move(width() - borderRight() - scrollbar->width(), borderTop());
+    if (style()->shouldPlaceBlockDirectionScrollbarOnLogicalLeft())
+        scrollRect.move(borderLeft(), borderTop());
+    else
+        scrollRect.move(width() - borderRight() - scrollbar->width(), borderTop());
     repaintRectangle(scrollRect);
 }
 
 IntRect RenderListBox::convertFromScrollbarToContainingView(const Scrollbar* scrollbar, const IntRect& scrollbarRect) const
 {
     RenderView* view = this->view();
     if (!view)
         return scrollbarRect;
 
     IntRect rect = scrollbarRect;
 
-    int scrollbarLeft = width() - borderRight() - scrollbar->width();
     int scrollbarTop = borderTop();
-    rect.move(scrollbarLeft, scrollbarTop);
+    rect.move(scrollbarLeft(), scrollbarTop);
 
     return view->frameView()->convertFromRenderer(this, rect);
 }
 
 IntRect RenderListBox::convertFromContainingViewToScrollbar(const Scrollbar* scrollbar, const IntRect& parentRect) const
 {
     RenderView* view = this->view();
     if (!view)
         return parentRect;
 
     IntRect rect = view->frameView()->convertToRenderer(this, parentRect);
 
-    int scrollbarLeft = width() - borderRight() - scrollbar->width();
     int scrollbarTop = borderTop();
-    rect.move(-scrollbarLeft, -scrollbarTop);
+    rect.move(-scrollbarLeft(), -scrollbarTop);
     return rect;
 }
 
 IntPoint RenderListBox::convertFromScrollbarToContainingView(const Scrollbar* scrollbar, const IntPoint& scrollbarPoint) const
 {
     RenderView* view = this->view();
     if (!view)
         return scrollbarPoint;
 
     IntPoint point = scrollbarPoint;
 
-    int scrollbarLeft = width() - borderRight() - scrollbar->width();
     int scrollbarTop = borderTop();
-    point.move(scrollbarLeft, scrollbarTop);
+    point.move(scrollbarLeft(), scrollbarTop);
 
     return view->frameView()->convertFromRenderer(this, point);
 }
 
 IntPoint RenderListBox::convertFromContainingViewToScrollbar(const Scrollbar* scrollbar, const IntPoint& parentPoint) const
 {
     RenderView* view = this->view();
     if (!view)
         return parentPoint;
 
     IntPoint point = view->frameView()->convertToRenderer(this, parentPoint);
 
-    int scrollbarLeft = width() - borderRight() - scrollbar->width();
     int scrollbarTop = borderTop();
-    point.move(-scrollbarLeft, -scrollbarTop);
+    point.move(-scrollbarLeft(), -scrollbarTop);
     return point;
 }
 
 IntSize RenderListBox::contentsSize() const
 {
     return IntSize(scrollWidth(), scrollHeight());
 }
 
 int RenderListBox::visibleHeight() const
 {
@@ skipping 113 matching lines @@
 
     if (m_vBar)
         m_vBar->styleChanged();
 
     // Force an update since we know the scrollbars have changed things.
     if (document().hasAnnotatedRegions())
         document().setAnnotatedRegionsDirty(true);
 }
 
 } // namespace WebCore