[Mac] (More) RTL support for tab strip

chrome/browser/ui/cocoa/tabs/tab_strip_controller.mm

 // Copyright (c) 2012 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.
 
 #import "chrome/browser/ui/cocoa/tabs/tab_strip_controller.h"
 
 #import <QuartzCore/QuartzCore.h>
 
 #include <cmath>
 #include <limits>
@@ skipping 124 matching lines @@
   bool animate_;
   DISALLOW_COPY_AND_ASSIGN(ScopedNSAnimationContextGroup);
 };
 
 CGFloat FlipXInView(NSView* view, CGFloat width, CGFloat x) {
   if (cocoa_l10n_util::ShouldDoExperimentalRTLLayout())
     return [view frame].size.width - x - width;
   return x;
 }
 
+NSRect FlipRectInView(NSView* view, NSRect rect) {
+  rect.origin.x = FlipXInView(view, NSWidth(rect), NSMinX(rect));
+  return rect;
+}
+
 }  // namespace
 
 @interface NSView (PrivateAPI)
 // Called by AppKit to check if dragging this view should move the window.
 // NSButton overrides this method in the same way so dragging window buttons
 // has no effect. NSView implementation returns NSZeroRect so the whole view
 // area can be dragged.
 - (NSRect)_opaqueRectForWindowMoveWhenInTitlebar;
 @end
 
@@ skipping 239 matching lines @@
 // in individual tab positioning (to avoid moving them right back to where they
 // were).
 //
 // In order to prevent actions being taken on tabs which are closing, the tab
 // itself gets marked as such so it no longer will send back its select action
 // or allow itself to be dragged. In addition, drags on the tab strip as a
 // whole are disabled while there are tabs closing.
 
 @implementation TabStripController
 
-@synthesize leftIndentForControls = leftIndentForControls_;
-@synthesize rightIndentForControls = rightIndentForControls_;
+@synthesize leadingIndentForControls = leadingIndentForControls_;
+@synthesize trailingIndentForControls = trailingIndentForControls_;
 
 - (id)initWithView:(TabStripView*)view
         switchView:(NSView*)switchView
            browser:(Browser*)browser
           delegate:(id<TabStripControllerDelegate>)delegate {
   DCHECK(view && switchView && browser && delegate);
   if ((self = [super init])) {
     tabStripView_.reset([view retain]);
     [tabStripView_ setController:self];
     switchView_ = switchView;
     browser_ = browser;
     tabStripModel_ = browser_->tab_strip_model();
     hoverTabSelector_.reset(new HoverTabSelector(tabStripModel_));
     delegate_ = delegate;
     bridge_.reset(new TabStripModelObserverBridge(tabStripModel_, self));
     dragController_.reset(
         [[TabStripDragController alloc] initWithTabStripController:self]);
     tabContentsArray_.reset([[NSMutableArray alloc] init]);
     tabArray_.reset([[NSMutableArray alloc] init]);
     NSWindow* browserWindow = [view window];
 
     // Important note: any non-tab subviews not added to |permanentSubviews_|
     // (see |-addSubviewToPermanentList:|) will be wiped out.
     permanentSubviews_.reset([[NSMutableArray alloc] init]);
 
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
     defaultFavicon_.reset(
         rb.GetNativeImageNamed(IDR_DEFAULT_FAVICON).CopyNSImage());
 
-    [self setLeftIndentForControls:[[self class] defaultLeftIndentForControls]];
-    [self setRightIndentForControls:0];
+    [self setLeadingIndentForControls:[[self class]
+                                          defaultLeadingIndentForControls]];
+    [self setTrailingIndentForControls:0];
 
     // Add this invisible view first so that it is ordered below other views.
     dragBlockingView_.reset(
         [[TabStripControllerDragBlockingView alloc] initWithFrame:NSZeroRect
                                                        controller:self]);
     [self addSubviewToPermanentList:dragBlockingView_];
 
     newTabButton_ = [view getNewTabButton];
     [newTabButton_ setWantsLayer:YES];
     [self addSubviewToPermanentList:newTabButton_];
@@ skipping 115 matching lines @@
   }
   [[NSNotificationCenter defaultCenter] removeObserver:self];
 
   browser_ = nullptr;
 }
 
 + (CGFloat)defaultTabHeight {
   return [TabController defaultTabHeight];
 }
 
-+ (CGFloat)defaultLeftIndentForControls {
++ (CGFloat)defaultLeadingIndentForControls {
   // Default indentation leaves enough room so tabs don't overlap with the
   // window controls.
   return 70.0;
 }
 
 + (CGFloat)tabOverlap {
   // The overlap value needs to be <= the x position of the favicon within a
   // tab. Else, every time the throbber is painted, the throbber's invalidation
   // will also invalidate parts of the tab to the left, and two tabs's
   // backgrounds need to be painted on each throbber frame instead of one.
@@ skipping 233 matching lines @@
       // resized until a later time (when the mouse leaves the tab strip).
       // However, if the tab being closed is a pinned tab, break out of
       // rapid-closure mode since the mouse is almost guaranteed not to be over
       // the closebox of the adjacent tab (due to the difference in widths).
       // TODO(pinkerton): re-visit when handling tab overflow.
       // http://crbug.com/188
       if (tabStripModel_->IsTabPinned(index)) {
         availableResizeWidth_ = kUseFullAvailableWidth;
       } else {
         NSView* penultimateTab = [self viewAtIndex:numberOfOpenTabs - 2];
-        availableResizeWidth_ = NSMaxX([penultimateTab frame]);
+        availableResizeWidth_ =
+            cocoa_l10n_util::ShouldDoExperimentalRTLLayout()
+                ? FlipXInView(tabStripView_, 0, NSMinX([penultimateTab frame]))
+                : NSMaxX([penultimateTab frame]);
       }
     } else {
-      // If the rightmost tab is closed, change the available width so that
+      // If the trailing tab is closed, change the available width so that
       // another tab's close button lands below the cursor (assuming the tabs
       // are currently below their maximum width and can grow).
       NSView* lastTab = [self viewAtIndex:numberOfOpenTabs - 1];
-      availableResizeWidth_ = NSMaxX([lastTab frame]);
+      availableResizeWidth_ =
+          cocoa_l10n_util::ShouldDoExperimentalRTLLayout()
+              ? FlipXInView(tabStripView_, 0, NSMinX([lastTab frame]))
+              : NSMaxX([lastTab frame]);
     }
     tabStripModel_->CloseWebContentsAt(
         index,
         TabStripModel::CLOSE_USER_GESTURE |
         TabStripModel::CLOSE_CREATE_HISTORICAL_TAB);
   } else {
     // Use the standard window close if this is the last tab
     // this prevents the tab from being removed from the model until after
     // the window dissapears
     [[tabStripView_ window] performClose:nil];
@@ skipping 35 matching lines @@
   placeholderFrame_ = frame;
   [self layoutTabsWithAnimation:initialLayoutComplete_ regenerateSubviews:NO];
 }
 
 - (BOOL)isDragSessionActive {
   return placeholderTab_ != nil;
 }
 
 - (BOOL)isTabFullyVisible:(TabView*)tab {
   NSRect frame = [tab frame];
-  return NSMinX(frame) >= [self leftIndentForControls] &&
-      NSMaxX(frame) <= [self tabAreaRightEdge];
+  if (cocoa_l10n_util::ShouldDoExperimentalRTLLayout()) {
+    return NSMinX(frame) >= [self trailingIndentForControls] &&
+           NSMaxX(frame) <= [self tabAreaRightEdge];
+  } else {
+    return NSMinX(frame) >= [self leadingIndentForControls] &&
+           NSMaxX(frame) <= [self tabAreaRightEdge];
+  }
 }
 
 - (CGFloat)tabAreaRightEdge {
-  return NSMaxX([tabStripView_ frame]) - [self rightIndentForControls];
+  CGFloat rightEdge = cocoa_l10n_util::ShouldDoExperimentalRTLLayout()
+                          ? [self leadingIndentForControls]
+                          : [self trailingIndentForControls];
+  return NSMaxX([tabStripView_ frame]) - rightEdge;
 }
 
 - (void)showNewTabButton:(BOOL)show {
   forceNewTabButtonHidden_ = show ? NO : YES;
   if (forceNewTabButtonHidden_)
     [newTabButton_ setHidden:YES];
 }
 
 // Lay out all tabs in the order of their TabContentsControllers, which matches
 // the ordering in the TabStripModel. This call isn't that expensive, though
@@ skipping 27 matching lines @@
   // (taken care of by |MAX()| when calculating tab sizes).
   CGFloat availableSpace = 0;
   if ([self inRapidClosureMode]) {
     availableSpace = availableResizeWidth_;
   } else {
     availableSpace = NSWidth([tabStripView_ frame]);
 
     // Account for the width of the new tab button.
     availableSpace -=
         NSWidth([newTabButton_ frame]) + kNewTabButtonOffset - kTabOverlap;
-    // Account for the right-side controls if not in rapid closure mode.
+    // Account for the trailing controls if not in rapid closure mode.
     // (In rapid closure mode, the available width is set based on the
-    // position of the rightmost tab, not based on the width of the tab strip,
-    // so the right controls have already been accounted for.)
-    availableSpace -= [self rightIndentForControls];
+    // position of the trailing tab, not based on the width of the tab strip,
+    // so the trailing controls have already been accounted for.)
+    availableSpace -= [self trailingIndentForControls];
   }
 
-  // Need to leave room for the left-side controls even in rapid closure mode.
-  availableSpace -= [self leftIndentForControls];
+  // Need to leave room for the leading controls even in rapid closure mode.
+  availableSpace -= [self leadingIndentForControls];
 
   // This may be negative, but that's okay (taken care of by |MAX()| when
   // calculating tab sizes). "pinned" tabs in horizontal mode just get a special
   // section, they don't change size.
   CGFloat availableSpaceForNonPinned = availableSpace;
   if ([self numberOfOpenPinnedTabs]) {
     availableSpaceForNonPinned -=
         [self numberOfOpenPinnedTabs] * (kPinnedTabWidth - kTabOverlap);
     availableSpaceForNonPinned -= kLastPinnedTabSpacing;
   }
@@ skipping 38 matching lines @@
     }
 
     // Separate integral and fractional parts.
     CGFloat integralPart = std::floor(nonPinnedTabWidth);
     nonPinnedTabWidthFraction = nonPinnedTabWidth - integralPart;
     nonPinnedTabWidth = integralPart;
   }
 
   BOOL visible = [[tabStripView_ window] isVisible];
 
-  CGFloat offset =
-      cocoa_l10n_util::ShouldDoExperimentalRTLLayout()
-          ? [self rightIndentForControls]
-          : [self leftIndentForControls];
+  CGFloat offset = [self leadingIndentForControls];
   bool hasPlaceholderGap = false;
   // Whether or not the last tab processed by the loop was a pinned tab.
   BOOL isLastTabPinned = NO;
   CGFloat tabWidthAccumulatedFraction = 0;
   NSInteger laidOutNonPinnedTabs = 0;
 
+  // Lay everything out as if it was LTR and flip at the end
+  // for RTL, if necessary.
   for (TabController* tab in tabArray_.get()) {
     // Ignore a tab that is going through a close animation.
     if ([closingControllers_ containsObject:tab])
       continue;
 
     BOOL isPlaceholder = [[tab view] isEqual:placeholderTab_];
     NSRect tabFrame = [[tab view] frame];
     tabFrame.size.height = [[self class] defaultTabHeight];
     tabFrame.origin.y = 0;
     tabFrame.origin.x = offset;
@@ skipping 14 matching lines @@
       [target setFrame:tabFrame];
 
       // Store the frame by identifier to avoid redundant calls to animator.
       NSValue* identifier = [NSValue valueWithPointer:[tab view]];
       [targetFrames_ setObject:[NSValue valueWithRect:tabFrame]
                         forKey:identifier];
       continue;
     }
 
     if (placeholderTab_ && !hasPlaceholderGap) {
-      const CGFloat placeholderMin = NSMinX(placeholderFrame_);
-      // If the left edge is to the left of the placeholder's left, but the
-      // mid is to the right of it slide over to make space for it.
-      if (NSMidX(tabFrame) > placeholderMin) {
+      // If the back edge is behind the placeholder's back edge, but the
+      // mid is in front of it of it, slide over to make space for it.
+      bool shouldLeaveGap;
+      if (cocoa_l10n_util::ShouldDoExperimentalRTLLayout()) {
+        const CGFloat tabMidpoint =
+            NSMidX(FlipRectInView(tabStripView_, tabFrame));
+        shouldLeaveGap = tabMidpoint < NSMaxX(placeholderFrame_);
+      } else {
+        shouldLeaveGap = NSMidX(tabFrame) > NSMinX(placeholderFrame_);
+      }
+      if (shouldLeaveGap) {
         hasPlaceholderGap = true;
         offset += NSWidth(placeholderFrame_);
         offset -= kTabOverlap;
         tabFrame.origin.x = offset;
       }
     }
 
     // Set the width. Selected tabs are slightly wider when things get really
     // small and thus we enforce a different minimum width.
     BOOL isPinned = [tab pinned];
@@ skipping 945 matching lines @@
             givesIndex:(NSInteger*)index
            disposition:(WindowOpenDisposition*)disposition {
   // Proportion of the tab which is considered the "middle" (and causes things
   // to drop on that tab).
   const double kMiddleProportion = 0.5;
   const double kLRProportion = (1.0 - kMiddleProportion) / 2.0;
   const CGFloat kTabOverlap = [TabStripController tabOverlap];
 
   DCHECK(index && disposition);
   NSInteger i = 0;
+  BOOL isRTL = cocoa_l10n_util::ShouldDoExperimentalRTLLayout();
   for (TabController* tab in tabArray_.get()) {
     NSView* view = [tab view];
     DCHECK([view isKindOfClass:[TabView class]]);
 
     // Recall that |-[NSView frame]| is in its superview's coordinates, so a
     // |TabView|'s frame is in the coordinates of the |TabStripView| (which
     // matches the coordinate system of |point|).
     NSRect frame = [view frame];
 
     // Modify the frame to make it "unoverlapped".
     frame.origin.x += kTabOverlap / 2.0;
     frame.size.width -= kTabOverlap;
     if (frame.size.width < 1.0)
       frame.size.width = 1.0;  // try to avoid complete failure
 
-    // Drop in a new tab to the left of tab |i|?
-    if (point.x < (frame.origin.x + kLRProportion * frame.size.width)) {
+    CGFloat rightEdge = NSMaxX(frame) - kLRProportion * frame.size.width;
+    CGFloat leftEdge = frame.origin.x + kLRProportion * frame.size.width;
+
+    // Drop in a new tab before  tab |i|?
+    if (isRTL ? point.x > rightEdge : point.x < leftEdge) {
       *index = i;
       *disposition = WindowOpenDisposition::NEW_FOREGROUND_TAB;
       return;
     }
 
     // Drop on tab |i|?
-    if (point.x <= (frame.origin.x +
-                       (1.0 - kLRProportion) * frame.size.width)) {
+    if (isRTL ? point.x >= leftEdge : point.x <= rightEdge) {
       *index = i;
       *disposition = WindowOpenDisposition::CURRENT_TAB;
       return;
     }
 
     // (Dropping in a new tab to the right of tab |i| will be taken care of in
     // the next iteration.)
     i++;
   }
 
@@ skipping 156 matching lines @@
   if (modelIndex < 0)
     return nil;
   NSInteger index = [self indexFromModelIndex:modelIndex];
   if (index < 0 ||
       index >= (NSInteger)[tabContentsArray_ count])
     return nil;
   return [tabContentsArray_ objectAtIndex:index];
 }
 
 - (void)addCustomWindowControls {
+  BOOL isRTL = cocoa_l10n_util::ShouldDoExperimentalRTLLayout();
   if (!customWindowControls_) {
     // Make the container view.
     CGFloat height = NSHeight([tabStripView_ frame]);
-    NSRect frame = NSMakeRect(0, 0, [self leftIndentForControls], height);
+    CGFloat width = [self leadingIndentForControls];
+    CGFloat xOrigin = isRTL ? NSWidth([tabStripView_ frame]) - width : 0;
+    NSRect frame = NSMakeRect(xOrigin, 0, width, height);
     customWindowControls_.reset(
         [[CustomWindowControlsView alloc] initWithFrame:frame]);
     [customWindowControls_
-        setAutoresizingMask:NSViewMaxXMargin | NSViewHeightSizable];
+        setAutoresizingMask:isRTL ? NSViewMaxXMargin | NSViewHeightSizable
+                                  : NSViewMinXMargin | NSViewHeightSizable];
 
     // Add the traffic light buttons. The horizontal layout was determined by
     // manual inspection on Yosemite.
     CGFloat closeButtonX = 11;
     CGFloat pinnedButtonX = 31;
     CGFloat zoomButtonX = 51;
+    if (isRTL)
+      std::swap(closeButtonX, zoomButtonX);
 
     NSUInteger styleMask = [[tabStripView_ window] styleMask];
     NSButton* closeButton = [NSWindow standardWindowButton:NSWindowCloseButton
                                               forStyleMask:styleMask];
 
     // Vertically center the buttons in the tab strip.
     CGFloat buttonY = floor((height - NSHeight([closeButton bounds])) / 2);
     [closeButton setFrameOrigin:NSMakePoint(closeButtonX, buttonY)];
     [customWindowControls_ addSubview:closeButton];
 
@@ skipping 11 matching lines @@
     [zoomButton setFrameOrigin:NSMakePoint(zoomButtonX, buttonY)];
 
     customWindowControlsTrackingArea_.reset([[CrTrackingArea alloc]
         initWithRect:[customWindowControls_ bounds]
              options:(NSTrackingMouseEnteredAndExited | NSTrackingActiveAlways)
                owner:self
             userInfo:nil]);
     [customWindowControls_
         addTrackingArea:customWindowControlsTrackingArea_.get()];
   }
-
+  if (isRTL &&
+      NSMaxX([customWindowControls_ frame]) != NSMaxX([tabStripView_ frame])) {
+    NSRect frame = [customWindowControls_ frame];
+    frame.origin.x =
+        NSMaxX([tabStripView_ frame]) - [self leadingIndentForControls];
+    [customWindowControls_ setFrame:frame];
+  }
   if (![permanentSubviews_ containsObject:customWindowControls_]) {
     [self addSubviewToPermanentList:customWindowControls_];
     [self regenerateSubviewList];
   }
 }
 
 - (void)removeCustomWindowControls {
   if (customWindowControls_)
     [permanentSubviews_ removeObject:customWindowControls_];
   [self regenerateSubviewList];
@@ skipping 59 matching lines @@
   for (int i = 0; i < tabStripModel_->count(); i++) {
     [self updateIconsForContents:tabStripModel_->GetWebContentsAt(i) atIndex:i];
   }
 }
 
 - (void)setVisualEffectsDisabledForFullscreen:(BOOL)fullscreen {
   [tabStripView_ setVisualEffectsDisabledForFullscreen:fullscreen];
 }
 
 @end