Make tabOverlap dynamic depending on the number of non-mini tabs presented on...

chrome/browser/cocoa/tab_strip_controller.mm

 // Copyright (c) 2010 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/cocoa/tab_strip_controller.h"
 
 #import <QuartzCore/QuartzCore.h>
 
 #include <limits>
 #include <string>
@@ skipping 50 matching lines @@
 // The width and height for a tab's icon.
 const CGFloat kIconWidthAndHeight = 16.0;
 
 // The amount by which the new tab button is offset (from the tabs).
 const CGFloat kNewTabButtonOffset = 8.0;
 
 // The amount by which to shrink the tab strip (on the right) when the
 // incognito badge is present.
 const CGFloat kIncognitoBadgeTabStripShrink = 18;
 
+// The minimum offset of the tab over another tab
+const CGFloat minTabOffset = 2.0;
+
 // Time (in seconds) in which tabs animate to their final position.
 const NSTimeInterval kAnimationDuration = 0.125;
 
 // Helper class for doing NSAnimationContext calls that takes a bool to disable
 // all the work.  Useful for code that wants to conditionally animate.
 class ScopedNSAnimationContextGroup {
  public:
   explicit ScopedNSAnimationContextGroup(bool animate)
       : animate_(animate) {
     if (animate_) {
@@ skipping 509 matching lines @@
 
 // Called when the user clicks a tab. Tell the model the selection has changed,
 // which feeds back into us via a notification.
 - (void)selectTab:(id)sender {
   DCHECK([sender isKindOfClass:[NSView class]]);
   int index = [self modelIndexForTabView:sender];
   if (tabStripModel_->ContainsIndex(index))
     tabStripModel_->SelectTabContentsAt(index, true);
 }
 
+- (NSView*)selectedTabView {
+        int selectedIndex = tabStripModel_->selected_index();
+        // Take closing tabs into account. They can't ever be selected.
+        selectedIndex = [self indexFromModelIndex:selectedIndex];
+        return [self viewAtIndex:selectedIndex];
+}
+
 // Called when the user closes a tab. Asks the model to close the tab. |sender|
 // is the TabView that is potentially going away.
 - (void)closeTab:(id)sender {
   DCHECK([sender isKindOfClass:[TabView class]]);
   if ([hoveredTab_ isEqual:sender]) {
     hoveredTab_ = nil;
   }
 
   NSInteger index = [self modelIndexForTabView:sender];
   if (!tabStripModel_->ContainsIndex(index))
@@ skipping 77 matching lines @@
 // if the window is visible and |animate| is YES.
 // TODO(pinkerton): Note this doesn't do too well when the number of min-sized
 // tabs would cause an overflow. http://crbug.com/188
 - (void)layoutTabsWithAnimation:(BOOL)animate
              regenerateSubviews:(BOOL)doUpdate {
   DCHECK([NSThread isMainThread]);
   if (![tabArray_ count])
     return;
 
   const CGFloat kMaxTabWidth = [TabController maxTabWidth];
-  const CGFloat kMinTabWidth = [TabController minTabWidth];
+  const CGFloat kMinTabWidth = [TabController miniTabWidth];
   const CGFloat kMinSelectedTabWidth = [TabController minSelectedTabWidth];
   const CGFloat kMiniTabWidth = [TabController miniTabWidth];
   const CGFloat kAppTabWidth = [TabController appTabWidth];
+  const CGFloat kHovTabWidth = [TabController maxTabWidth] / 2;
 
   NSRect enclosingRect = NSZeroRect;
   ScopedNSAnimationContextGroup mainAnimationGroup(animate);
   mainAnimationGroup.SetCurrentContextDuration(kAnimationDuration);
 
   // Update the current subviews and their z-order if requested.
   if (doUpdate)
     [self regenerateSubviewList];
 
   // Compute the base width of tabs given how much room we're allowed. Note that
@@ skipping 21 matching lines @@
   // section, they don't change size.
   CGFloat availableSpaceForNonMini = availableSpace;
   if (!verticalLayout_) {
       availableSpaceForNonMini -=
           [self numberOfOpenMiniTabs] * (kMiniTabWidth - kTabOverlap);
   }
 
   // Initialize |nonMiniTabWidth| in case there aren't any non-mini-tabs; this
   // value shouldn't actually be used.
   CGFloat nonMiniTabWidth = kMaxTabWidth;
+  CGFloat availableSpaceForNewOverlap = availableSpaceForNonMini;
+  CGFloat tabOverlap = kTabOverlap;
   const NSInteger numberOfOpenNonMiniTabs = [self numberOfOpenNonMiniTabs];
   if (!verticalLayout_ && numberOfOpenNonMiniTabs) {
     // Find the width of a non-mini-tab. This only applies to horizontal
     // mode. Add in the amount we "get back" from the tabs overlapping.
+
     availableSpaceForNonMini += (numberOfOpenNonMiniTabs - 1) * kTabOverlap;
 
     // Divide up the space between the non-mini-tabs.
     nonMiniTabWidth = availableSpaceForNonMini / numberOfOpenNonMiniTabs;
 
+
+        // This is one of the approach to solve the tab overflow problem.
+        // Find new tab overlap for all non-mini-tab
+  CGFloat extraSpace = kMinTabWidth * numberOfOpenNonMiniTabs - availableSpaceForNewOverlap;
+        if (nonMiniTabWidth < kMinTabWidth) {
+                tabOverlap = MIN(kMiniTabWidth - minTabOffset,
+                        extraSpace / (numberOfOpenNonMiniTabs - 1));
+        }
+
     // Clamp the width between the max and min.
-    nonMiniTabWidth = MAX(MIN(nonMiniTabWidth, kMaxTabWidth), kMinTabWidth);
+        nonMiniTabWidth = MAX(MIN(nonMiniTabWidth, kMaxTabWidth), kMinTabWidth);
   }
 
   BOOL visible = [[tabStripView_ window] isVisible];
 
   CGFloat offset = [self indentForControls];
   NSUInteger i = 0;
   bool hasPlaceholderGap = false;
   for (TabController* tab in tabArray_.get()) {
     // Ignore a tab that is going through a close animation.
     if ([closingControllers_ containsObject:tab])
@@ skipping 46 matching lines @@
           hasPlaceholderGap = true;
           offset += NSHeight(placeholderFrame_);
           tabFrame.origin.y = availableSpace - tabFrame.size.height - offset;
         }
       } else {
         // 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) {
           hasPlaceholderGap = true;
           offset += NSWidth(placeholderFrame_);
-          offset -= kTabOverlap;
+          offset -= tabOverlap;
           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.
     tabFrame.size.width = [tab mini] ?
         ([tab app] ? kAppTabWidth : kMiniTabWidth) : nonMiniTabWidth;
-    if ([tab selected])
-      tabFrame.size.width = MAX(tabFrame.size.width, kMinSelectedTabWidth);
+
+        // Added width for hovered tab
+        tabFrame.size.width = [tab selected] ?
+                MAX(tabFrame.size.width, kMinSelectedTabWidth) :
+                        ([tab hovered] && ![tab mini] && ![tab app] ?
+                                MAX(tabFrame.size.width, kHovTabWidth) : tabFrame.size.width);
 
     // Animate a new tab in by putting it below the horizon unless told to put
     // it in a specific location (i.e., from a drop).
     // TODO(pinkerton): figure out vertical tab animations.
     if (newTab && visible && animate) {
       if (NSEqualRects(droppedTabFrame_, NSZeroRect)) {
         [[tab view] setFrame:NSOffsetRect(tabFrame, 0, -NSHeight(tabFrame))];
       } else {
         [[tab view] setFrame:droppedTabFrame_];
         droppedTabFrame_ = NSZeroRect;
@@ skipping 10 matching lines @@
       [targetFrames_ setObject:[NSValue valueWithRect:tabFrame]
                         forKey:identifier];
     }
 
     enclosingRect = NSUnionRect(tabFrame, enclosingRect);
 
     if (verticalLayout_) {
       offset += NSHeight(tabFrame);
     } else {
       offset += NSWidth(tabFrame);
-      offset -= kTabOverlap;
+          offset -= [tab mini] || [tab app] ? kTabOverlap : tabOverlap;
     }
     i++;
   }
 
   // Hide the new tab button if we're explicitly told to. It may already
   // be hidden, doing it again doesn't hurt. Otherwise position it
   // appropriately, showing it if necessary.
   if (forceNewTabButtonHidden_) {
     [newTabButton_ setHidden:YES];
   } else {
     NSRect newTabNewFrame = [newTabButton_ frame];
     // We've already ensured there's enough space for the new tab button
     // so we don't have to check it against the available space. We do need
     // to make sure we put it after any placeholder.
-    newTabNewFrame.origin = NSMakePoint(offset, 0);
+    newTabNewFrame.origin = NSMakePoint(offset + (tabOverlap - kTabOverlap) + kNewTabButtonOffset, 0);
     newTabNewFrame.origin.x = MAX(newTabNewFrame.origin.x,
                                   NSMaxX(placeholderFrame_)) +
                                       kNewTabButtonOffset;
     if ([tabContentsArray_ count])
       [newTabButton_ setHidden:NO];
 
     if (!NSEqualRects(newTabTargetFrame_, newTabNewFrame)) {
       // Set the new tab button image correctly based on where the cursor is.
       NSWindow* window = [tabStripView_ window];
       NSPoint currentMouse = [window mouseLocationOutsideOfEventStream];
@@ skipping 445 matching lines @@
 }
 
 - (void)setFrameOfSelectedTab:(NSRect)frame {
   NSView* view = [self selectedTabView];
   NSValue* identifier = [NSValue valueWithPointer:view];
   [targetFrames_ setObject:[NSValue valueWithRect:frame]
                     forKey:identifier];
   [view setFrame:frame];
 }
 
-- (NSView*)selectedTabView {
-  int selectedIndex = tabStripModel_->selected_index();
-  // Take closing tabs into account. They can't ever be selected.
-  selectedIndex = [self indexFromModelIndex:selectedIndex];
-  return [self viewAtIndex:selectedIndex];
-}
-
 // Find the model index based on the x coordinate of the placeholder. If there
 // is no placeholder, this returns the end of the tab strip. Closing tabs are
 // not considered in computing the index.
 - (int)indexOfPlaceholder {
   double placeholderX = placeholderFrame_.origin.x;
   int index = 0;
   int location = 0;
   // Use |tabArray_| here instead of the tab strip count in order to get the
   // correct index when there are closing tabs to the left of the placeholder.
   const int count = [tabArray_ count];
@@ skipping 108 matching lines @@
     if ([[tabView superview] isKindOfClass:[TabView class]]) {
       tabView = (TabView*)[targetView superview];
     } else {
       tabView = nil;
     }
   }
 
   if (hoveredTab_ != tabView) {
     [hoveredTab_ mouseExited:nil];  // We don't pass event because moved events
     [tabView mouseEntered:nil];  // don't have valid tracking areas
-    hoveredTab_ = tabView;
+        hoveredTab_ = tabView;
+    [self layoutTabsWithAnimation:YES regenerateSubviews:NO];
   } else {
     [hoveredTab_ mouseMoved:event];
   }
 }
 
 - (void)mouseEntered:(NSEvent*)event {
   NSTrackingArea* area = [event trackingArea];
   if ([area isEqual:trackingArea_]) {
     mouseInside_ = YES;
     [self setTabTrackingAreasEnabled:YES];
     [self mouseMoved:event];
+
+
+          NSView* targetView = [tabStripView_ hitTest:[event locationInWindow]];
+          if ([targetView isKindOfClass:[TabView class]]) {
+            [self layoutTabsWithAnimation:YES regenerateSubviews:NO];
+          }
   }
 }
 
 // Called when the tracking area is in effect which means we're tracking to
 // see if the user leaves the tab strip with their mouse. When they do,
 // reset layout to use all available width.
 - (void)mouseExited:(NSEvent*)event {
   NSTrackingArea* area = [event trackingArea];
   if ([area isEqual:trackingArea_]) {
     mouseInside_ = NO;
@@ skipping 334 matching lines @@
     return;
 
   TabContentsController* tabController =
       [tabContentsArray_ objectAtIndex:index];
   TabContents* devtoolsContents = contents ?
       DevToolsWindow::GetDevToolsContents(contents) : NULL;
   [tabController showDevToolsContents:devtoolsContents];
 }
 
 @end