Clean up RTL methods....

views/view.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "views/view.h"
 
 #include <algorithm>
 #ifndef NDEBUG
 #include <iostream>
 #endif
@@ skipping 268 matching lines @@
 
 gfx::Rect View::GetVisibleBounds() {
   if (!IsVisibleInRootView())
     return gfx::Rect();
   gfx::Rect vis_bounds(0, 0, width(), height());
   gfx::Rect ancestor_bounds;
   View* view = this;
   int root_x = 0;
   int root_y = 0;
   while (view != NULL && !vis_bounds.IsEmpty()) {
-    root_x += view->GetX(APPLY_MIRRORING_TRANSFORMATION);
+    root_x += view->GetMirroredX();
     root_y += view->y();
-    vis_bounds.Offset(view->GetX(APPLY_MIRRORING_TRANSFORMATION), view->y());
+    vis_bounds.Offset(view->GetMirroredX(), view->y());
     View* ancestor = view->GetParent();
     if (ancestor != NULL) {
       ancestor_bounds.SetRect(0, 0, ancestor->width(),
         ancestor->height());
       vis_bounds = vis_bounds.Intersect(ancestor_bounds);
     } else if (!view->GetWidget()) {
       // If the view has no Widget, we're not visible. Return an empty rect.
       return gfx::Rect();
     }
     view = ancestor;
@@ skipping 69 matching lines @@
     SchedulePaint();
   }
 }
 
 bool View::IsEnabled() const {
   return enabled_;
 }
 
 // RTL positioning -------------------------------------------------------------
 
-gfx::Rect View::GetBounds(PositionMirroringSettings settings) const {
+gfx::Rect View::GetMirroredBounds() const {
   gfx::Rect bounds(bounds_);
-
-  // If the parent uses an RTL UI layout and if we are asked to transform the
-  // bounds to their mirrored position if necessary, then we should shift the
-  // rectangle appropriately.
-  if (settings == APPLY_MIRRORING_TRANSFORMATION)
-    bounds.set_x(MirroredX());
-
+  bounds.set_x(GetMirroredX());
   return bounds;
 }
 
-// y(), width() and height() are agnostic to the RTL UI layout of the
-// parent view. x(), on the other hand, is not.
-int View::GetX(PositionMirroringSettings settings) const {
-  return settings == IGNORE_MIRRORING_TRANSFORMATION ? x() : MirroredX();
+gfx::Point View::GetMirroredPosition() const {
+  return gfx::Point(GetMirroredX(), y());
 }
 
-gfx::Point View::GetPosition() const {
-  return gfx::Point(GetX(APPLY_MIRRORING_TRANSFORMATION), y());
+int View::GetMirroredX() const {
+  View* parent = GetParent();
+  return parent ? parent->GetMirroredXForRect(bounds_) : x();
 }
 
-int View::MirroredX() const {
-  View* parent = GetParent();
-  return parent ? parent->MirroredLeftPointForRect(bounds_) : x();
+int View::GetMirroredXForRect(const gfx::Rect& bounds) const {
+  return base::i18n::IsRTL() ?
+      (width() - bounds.x() - bounds.width()) : bounds.x();
 }
 
-int View::MirroredLeftPointForRect(const gfx::Rect& bounds) const {
-  return base::i18n::IsRTL() ?
-      (width() - bounds.x() - bounds.width()) : bounds.x();
+int View::GetMirroredXInView(int x) const {
+  return base::i18n::IsRTL() ? width() - x : x;
+}
+
+int View::GetMirroredXWithWidthInView(int x, int w) const {
+  return base::i18n::IsRTL() ? width() - x - w : x;
 }
 
 // Layout ----------------------------------------------------------------------
 
 void View::Layout() {
   needs_layout_ = false;
 
   // If we have a layout manager, let it handle the layout for us.
   if (layout_manager_.get()) {
     layout_manager_->Layout(this);
@@ skipping 107 matching lines @@
   ConvertPointToView(src, dst, point, true);
 }
 
 // static
 void View::ConvertPointToWidget(const View* src, gfx::Point* p) {
   DCHECK(src);
   DCHECK(p);
 
   gfx::Point offset;
   for (const View* v = src; v; v = v->GetParent()) {
-    offset.set_x(offset.x() + v->GetX(APPLY_MIRRORING_TRANSFORMATION));
+    offset.set_x(offset.x() + v->GetMirroredX());
     offset.set_y(offset.y() + v->y());
   }
   p->SetPoint(p->x() + offset.x(), p->y() + offset.y());
 }
 
 // static
 void View::ConvertPointFromWidget(const View* dest, gfx::Point* p) {
   gfx::Point t;
   ConvertPointToWidget(dest, &t);
   p->SetPoint(p->x() - t.x(), p->y() - t.y());
@@ skipping 17 matching lines @@
 // Painting --------------------------------------------------------------------
 
 void View::SchedulePaint(const gfx::Rect& r, bool urgent) {
   if (!IsVisible())
     return;
 
   if (parent_) {
     // Translate the requested paint rect to the parent's coordinate system
     // then pass this notification up to the parent.
     gfx::Rect paint_rect = r;
-    paint_rect.Offset(GetPosition());
+    paint_rect.Offset(GetMirroredPosition());
     parent_->SchedulePaint(paint_rect, urgent);
   }
 }
 
 void View::SchedulePaint() {
   SchedulePaint(GetContentsBounds(), false);
 }
 
 void View::Paint(gfx::Canvas* canvas) {
   PaintBackground(canvas);
@@ skipping 32 matching lines @@
   // We're going to modify the canvas, save it's state first.
   canvas->Save();
 
   // Paint this View and its children, setting the clip rect to the bounds
   // of this View and translating the origin to the local bounds' top left
   // point.
   //
   // Note that the X (or left) position we pass to ClipRectInt takes into
   // consideration whether or not the view uses a right-to-left layout so that
   // we paint our view in its mirrored position if need be.
-  if (canvas->ClipRectInt(MirroredX(), y(), width(), height())) {
+  if (canvas->ClipRectInt(GetMirroredX(), y(), width(), height())) {
     // Non-empty clip, translate the graphics such that 0,0 corresponds to
     // where this view is located (related to its parent).
-    canvas->TranslateInt(MirroredX(), y());
+    canvas->TranslateInt(GetMirroredX(), y());
 
     // If the View we are about to paint requested the canvas to be flipped, we
     // should change the transform appropriately.
     canvas->Save();
     if (FlipCanvasOnPaintForRTLUI()) {
       canvas->TranslateInt(width(), 0);
       canvas->ScaleInt(-1, 1);
     }
 
     Paint(canvas);
@@ skipping 315 matching lines @@
 
 // Scrolling -------------------------------------------------------------------
 
 void View::ScrollRectToVisible(const gfx::Rect& rect) {
   View* parent = GetParent();
 
   // We must take RTL UI mirroring into account when adjusting the position of
   // the region.
   if (parent) {
     gfx::Rect scroll_rect(rect);
-    scroll_rect.Offset(GetX(APPLY_MIRRORING_TRANSFORMATION), y());
+    scroll_rect.Offset(GetMirroredX(), y());
     parent->ScrollRectToVisible(scroll_rect);
   }
 }
 
 int View::GetPageScrollIncrement(ScrollView* scroll_view,
                                  bool is_horizontal, bool is_positive) {
   return 0;
 }
 
 int View::GetLineScrollIncrement(ScrollView* scroll_view,
@@ skipping 353 matching lines @@
                               const View* dst,
                               gfx::Point* point,
                               bool try_other_direction) {
   // src can be NULL
   DCHECK(dst);
   DCHECK(point);
 
   const View* v;
   gfx::Point offset;
 
-  for (v = dst; v && v != src; v = v->GetParent()) {
-    offset.SetPoint(offset.x() + v->GetX(APPLY_MIRRORING_TRANSFORMATION),
-                    offset.y() + v->y());
-  }
+  for (v = dst; v && v != src; v = v->GetParent())
+    offset.SetPoint(offset.x() + v->GetMirroredX(), offset.y() + v->y());
 
   // The source was not found. The caller wants a conversion
   // from a view to a transitive parent.
   if (src && v == NULL && try_other_direction) {
     gfx::Point p;
     // note: try_other_direction is force to FALSE so we don't
     // end up in an infinite recursion should both src and dst
     // are not parented.
     ConvertPointToView(dst, src, &p, false);
     // since the src and dst are inverted, p should also be negated
@@ skipping 218 matching lines @@
   OSExchangeData data;
   WriteDragData(press_pt, &data);
 
   // Message the RootView to do the drag and drop. That way if we're removed
   // the RootView can detect it and avoid calling us back.
   RootView* root_view = GetRootView();
   root_view->StartDragForViewFromMouseEvent(this, data, drag_operations);
 }
 
 }  // namespace views