[Blink] Adding Writing direction to the context menu for Aura.

Source/core/platform/ScrollView.cpp

 /*
  * Copyright (C) 2006, 2007, 2008 Apple Inc. All rights reserved.
  *
  * 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.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 166 matching lines @@
     m_clipsRepaints = clipsRepaints;
 }
 
 IntSize ScrollView::unscaledVisibleContentSize(IncludeScrollbarsInRect scrollbarInclusion) const
 {
     return scrollbarInclusion == ExcludeScrollbars ? excludeScrollbars(frameRect().size()) : frameRect().size();
 }
 
 IntSize ScrollView::excludeScrollbars(const IntSize& size) const
 {
-    int verticalScrollbarWidth = 0;
+//    int verticalScrollbarWidth = 0;
     int horizontalScrollbarHeight = 0;
 
-    if (Scrollbar* verticalBar = verticalScrollbar())
-        verticalScrollbarWidth = !verticalBar->isOverlayScrollbar() ? verticalBar->width() : 0;
+//    if (Scrollbar* verticalBar = verticalScrollbar())
+//      verticalScrollbarWidth = !verticalBar->isOverlayScrollbar() ? verticalBar->width() : 0;
     if (Scrollbar* horizontalBar = horizontalScrollbar())
         horizontalScrollbarHeight = !horizontalBar->isOverlayScrollbar() ? horizontalBar->height() : 0;
 
-    return IntSize(max(0, size.width() - verticalScrollbarWidth),
+    return IntSize(max(0, size.width()),
         max(0, size.height() - horizontalScrollbarHeight));
 
 }
 
 IntRect ScrollView::visibleContentRect(IncludeScrollbarsInRect scollbarInclusion) const
 {
     FloatSize visibleContentSize = unscaledVisibleContentSize(scollbarInclusion);
     visibleContentSize.scale(1 / visibleContentScaleFactor());
     return IntRect(IntPoint(m_scrollOffset), expandedIntSize(visibleContentSize));
 }
@@ skipping 285 matching lines @@
     if (m_verticalScrollbar)
         m_verticalScrollbar->offsetDidChange();
 
     m_inUpdateScrollbars = false;
 }
 
 const int panIconSizeLength = 16;
 
 IntRect ScrollView::rectToCopyOnScroll() const
 {
-    IntRect scrollViewRect = convertToRootView(IntRect((shouldPlaceVerticalScrollbarOnLeft() && verticalScrollbar()) ? verticalScrollbar()->width() : 0, 0, visibleWidth(), visibleHeight()));
+    // IntRect scrollViewRect = convertToRootView(IntRect((shouldPlaceVerticalScrollbarOnLeft() && verticalScrollbar()) ? verticalScrollbar()->width() : 0, 0, visibleWidth(), visibleHeight()));
+    IntRect scrollViewRect = convertToRootView(IntRect(0, 0, visibleWidth(), visibleHeight()));
     if (hasOverlayScrollbars()) {
         int verticalScrollbarWidth = (verticalScrollbar() && !hasLayerForVerticalScrollbar()) ? verticalScrollbar()->width() : 0;
         int horizontalScrollbarHeight = (horizontalScrollbar() && !hasLayerForHorizontalScrollbar()) ? horizontalScrollbar()->height() : 0;
 
         scrollViewRect.setWidth(scrollViewRect.width() - verticalScrollbarWidth);
         scrollViewRect.setHeight(scrollViewRect.height() - horizontalScrollbarHeight);
     }
     return scrollViewRect;
 }
 
@@ skipping 44 matching lines @@
 }
 
 void ScrollView::scrollContentsSlowPath(const IntRect& updateRect)
 {
     hostWindow()->invalidateContentsForSlowScroll(updateRect);
 }
 
 IntPoint ScrollView::rootViewToContents(const IntPoint& rootViewPoint) const
 {
     IntPoint viewPoint = convertFromRootView(rootViewPoint);
+    viewPoint.move(-verticalScrollbarWidth(), 0);
     return viewPoint + scrollOffset();
 }
 
 IntPoint ScrollView::contentsToRootView(const IntPoint& contentsPoint) const
 {
     IntPoint viewPoint = contentsPoint - scrollOffset();
+    viewPoint.move(verticalScrollbarWidth(), 0);
     return convertToRootView(viewPoint);
 }
 
 IntRect ScrollView::rootViewToContents(const IntRect& rootViewRect) const
 {
     IntRect viewRect = convertFromRootView(rootViewRect);
     viewRect.move(scrollOffset());
+    viewRect.move(-verticalScrollbarWidth(), 0);
     return viewRect;
 }
 
 IntRect ScrollView::contentsToRootView(const IntRect& contentsRect) const
 {
     IntRect viewRect = contentsRect;
     viewRect.move(-scrollOffset());
+    viewRect.move(verticalScrollbarWidth(), 0);
     return convertToRootView(viewRect);
 }
 
 IntPoint ScrollView::windowToContents(const IntPoint& windowPoint) const
 {
     IntPoint viewPoint = convertFromContainingWindow(windowPoint);
+    viewPoint.move(-verticalScrollbarWidth(), 0);
     return viewPoint + scrollOffset();
 }
 
 IntPoint ScrollView::contentsToWindow(const IntPoint& contentsPoint) const
 {
     IntPoint viewPoint = contentsPoint - scrollOffset();
+    viewPoint.move(verticalScrollbarWidth(), 0);
     return convertToContainingWindow(viewPoint);
 }
 
 IntRect ScrollView::windowToContents(const IntRect& windowRect) const
 {
     IntRect viewRect = convertFromContainingWindow(windowRect);
     viewRect.move(scrollOffset());
+    viewRect.move(-verticalScrollbarWidth(), 0);
     return viewRect;
 }
 
 IntRect ScrollView::contentsToWindow(const IntRect& contentsRect) const
 {
     IntRect viewRect = contentsRect;
     viewRect.move(-scrollOffset());
+    viewRect.move(verticalScrollbarWidth(), 0);
     return convertToContainingWindow(viewRect);
 }
 
 IntRect ScrollView::contentsToScreen(const IntRect& rect) const
 {
     HostWindow* window = hostWindow();
     if (!window)
         return IntRect();
     return window->rootViewToScreen(contentsToRootView(rect));
 }
@@ skipping 140 matching lines @@
 bool ScrollView::userInputScrollable(ScrollbarOrientation orientation) const
 {
     ScrollbarMode mode = (orientation == HorizontalScrollbar) ?
         m_horizontalScrollbarMode : m_verticalScrollbarMode;
 
     return mode == ScrollbarAuto || mode == ScrollbarAlwaysOn;
 }
 
 bool ScrollView::shouldPlaceVerticalScrollbarOnLeft() const
 {
-    return false;
+    return true;
 }
 
 void ScrollView::repaintContentRectangle(const IntRect& rect)
 {
     IntRect paintRect = rect;
     if (clipsRepaints() && !paintsEntireContents())
         paintRect.intersect(visibleContentRect());
     if (paintRect.isEmpty())
         return;
 
@@ skipping 81 matching lines @@
 }
 
 void ScrollView::paint(GraphicsContext* context, const IntRect& rect)
 {
     if (context->paintingDisabled() && !context->updatingControlTints())
         return;
 
     notifyPageThatContentAreaWillPaint();
 
     IntRect documentDirtyRect = rect;
+    documentDirtyRect.move(-verticalScrollbarWidth(), 0);
+    documentDirtyRect.setWidth(rect.width() + 2*verticalScrollbarWidth());
     if (!paintsEntireContents()) {
         IntRect visibleAreaWithoutScrollbars(location(), visibleContentRect().size());
         documentDirtyRect.intersect(visibleAreaWithoutScrollbars);
     }
 
     if (!documentDirtyRect.isEmpty()) {
         GraphicsContextStateSaver stateSaver(*context);
 
-        context->translate(x(), y());
+        context->translate(x() + verticalScrollbarWidth(), y());
         documentDirtyRect.moveBy(-location());
 
         if (!paintsEntireContents()) {
             context->translate(-scrollX(), -scrollY());
             documentDirtyRect.moveBy(scrollPosition());
 
             context->clip(visibleContentRect());
         }
 
         paintContents(context, documentDirtyRect);
@@ skipping 244 matching lines @@
 int ScrollView::pageStep(ScrollbarOrientation orientation) const
 {
     int length = (orientation == HorizontalScrollbar) ? visibleWidth() : visibleHeight();
     int minPageStep = static_cast<float>(length) * minFractionToStepWhenPaging();
     int pageStep = std::max(minPageStep, length - maxOverlapBetweenPages());
 
     return std::max(pageStep, 1);
 }
 
 } // namespace WebCore