Implement feature where tabs don't resize when using the close box until the ...

chrome/browser/cocoa/tab_strip_controller.mm

 // Copyright (c) 2009 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"
 
 #include "app/l10n_util.h"
 #include "base/mac_util.h"
 #include "base/sys_string_conversions.h"
 #include "chrome/app/chrome_dll_resource.h"
@@ skipping 11 matching lines @@
 #include "chrome/browser/tab_contents/navigation_controller.h"
 #include "chrome/browser/tab_contents/navigation_entry.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/tab_contents/tab_contents_view.h"
 #include "chrome/browser/tabs/tab_strip_model.h"
 #include "grit/generated_resources.h"
 #include "skia/ext/skia_utils_mac.h"
 
 NSString* const kTabStripNumberOfTabsChanged = @"kTabStripNumberOfTabsChanged";
 
+// A value to indicate tab layout should use the full available width of the
+// view.
+static const float kUseFullAvailableWidth = -1.0;
+
 // A simple view class that prevents the windowserver from dragging the
 // area behind tabs. Sometimes core animation confuses it.
 @interface TabStripControllerDragBlockingView : NSView
 @end
 @implementation TabStripControllerDragBlockingView
 - (BOOL)mouseDownCanMoveWindow {return NO;}
 - (void)drawRect:(NSRect)rect {}
 @end
 
+@interface TabStripController(Private)
+- (void)installTrackingArea;
+- (BOOL)useFullWidthForLayout;
+@end
+
 @implementation TabStripController
 
 - (id)initWithView:(TabStripView*)view
         switchView:(NSView*)switchView
              model:(TabStripModel*)model {
   DCHECK(view && switchView && model);
   if ((self = [super init])) {
     tabView_ = view;
     switchView_ = switchView;
     tabModel_ = model;
     bridge_.reset(new TabStripModelObserverBridge(tabModel_, self));
     tabContentsArray_.reset([[NSMutableArray alloc] init]);
     tabArray_.reset([[NSMutableArray alloc] init]);
     // Take the only child view present in the nib as the new tab button. For
     // some reason, if the view is present in the nib apriori, it draws
     // correctly. If we create it in code and add it to the tab view, it draws
     // with all sorts of crazy artifacts.
     newTabButton_ = [[tabView_ subviews] objectAtIndex:0];
     DCHECK([newTabButton_ isKindOfClass:[NSButton class]]);
     [newTabButton_ setTarget:nil];
     [newTabButton_ setAction:@selector(commandDispatch:)];
     [newTabButton_ setTag:IDC_NEW_TAB];
     targetFrames_.reset([[NSMutableDictionary alloc] init]);
     [tabView_ setWantsLayer:YES];
     dragBlockingView_.reset([[TabStripControllerDragBlockingView alloc]
                               initWithFrame:NSZeroRect]);
     [view addSubview:dragBlockingView_];
     newTabTargetFrame_ = NSMakeRect(0, 0, 0, 0);
+    availableResizeWidth_ = kUseFullAvailableWidth;
 
     // Watch for notifications that the tab strip view has changed size so
     // we can tell it to layout for the new size.
     [[NSNotificationCenter defaultCenter]
         addObserver:self
            selector:@selector(tabViewFrameChanged:)
                name:NSViewFrameDidChangeNotification
              object:tabView_];
   }
   return self;
 }
 
 - (void)dealloc {
+  [tabView_ removeTrackingArea:closeTabTrackingArea_.get()];
   [[NSNotificationCenter defaultCenter] removeObserver:self];
   [super dealloc];
 }
 
 + (CGFloat)defaultTabHeight {
   return 24.0;
 }
 
 // Finds the associated TabContentsController at the given |index| and swaps
 // out the sole child of the contentArea to display its contents.
@@ skipping 58 matching lines @@
 // get the associated view. Returns nil if out of range.
 - (NSView*)viewAtIndex:(NSUInteger)index {
   if (index >= [tabArray_ count])
     return NULL;
   return [[tabArray_ objectAtIndex:index] view];
 }
 
 // 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 indexForTabView:sender];
   if (index >= 0 && tabModel_->ContainsIndex(index))
     tabModel_->SelectTabContentsAt(index, true);
 }
 
-// Called when the user closes a tab.  Asks the model to close the tab.
+// 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:[NSView class]]);
   int index = [self indexForTabView:sender];
   if (tabModel_->ContainsIndex(index)) {
     TabContents* contents = tabModel_->GetTabContentsAt(index);
     if (contents)
       UserMetrics::RecordAction(L"CloseTab_Mouse", contents->profile());
     if ([self numberOfTabViews] > 1) {
+      // Limit the width available for laying out tabs so that tabs are not
+      // resized until a later time (when the mouse leaves the tab strip).
+      NSView* penultimateTab = [self viewAtIndex:[tabArray_ count] - 2];

[rohitrao (ping after 24h), 2009/07/24 20:35:57]

Will we have to revisit this once we implement reasonable tab overflow behavior?
 If so, add a TODO?

+      availableResizeWidth_ = NSMaxX([penultimateTab frame]);
+      [self installTrackingArea];
       tabModel_->CloseTabContentsAt(index);
     } 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
       [[tabView_ window] performClose:nil];
     }
   }
 }
 
@@ skipping 35 matching lines @@
   const float kTabOverlap = 20.0;
   const float kNewTabButtonOffset = 8.0;
   const float kMaxTabWidth = [TabController maxTabWidth];
   const float kMinTabWidth = [TabController minTabWidth];
   const float kMinSelectedTabWidth = [TabController minSelectedTabWidth];
 
   NSRect enclosingRect = NSZeroRect;
   [NSAnimationContext beginGrouping];
   [[NSAnimationContext currentContext] setDuration:0.2];
 
-  // Compute the base width of tabs given how much size we have available.
-  float availableWidth =
-      NSWidth([tabView_ frame]) - NSWidth([newTabButton_ frame]) -
-      kNewTabButtonOffset - kIndentLeavingSpaceForControls;
+  // Compute the base width of tabs given how much room we're allowed. We
+  // may not be able to use the entire width if the user is quickly closing
+  // tabs.
+  float availableWidth = 0;
+  if ([self useFullWidthForLayout]) {
+    availableWidth = NSWidth([tabView_ frame]);
+    availableWidth -= NSWidth([newTabButton_ frame]) + kNewTabButtonOffset;
+  } else {
+    availableWidth = availableResizeWidth_;
+  }
+  availableWidth -= kIndentLeavingSpaceForControls;
+
   // Add back in the amount we "get back" from the tabs overlapping.
-  availableWidth += [tabContentsArray_ count] * kTabOverlap;
+  availableWidth += ([tabContentsArray_ count] - 1) * kTabOverlap;
   const float baseTabWidth =
       MAX(MIN(availableWidth / [tabContentsArray_ count],
               kMaxTabWidth),
           kMinTabWidth);
 
   CGFloat minX = NSMinX(placeholderFrame_);
   BOOL visible = [[tabView_ window] isVisible];
 
   float offset = kIndentLeavingSpaceForControls;
   NSUInteger i = 0;
@@ skipping 57 matching lines @@
       NSValue *oldTargetValue = [targetFrames_ objectForKey:identifier];
       if (!oldTargetValue ||
           !NSEqualRects([oldTargetValue rectValue], tabFrame)) {
         [frameTarget setFrame:tabFrame];
         [targetFrames_ setObject:[NSValue valueWithRect:tabFrame]
                           forKey:identifier];
       }
       enclosingRect = NSUnionRect(tabFrame, enclosingRect);
     }
 
+#if 0
     // Ensure the current tab is "below" the tab before it in z-order so that
     // all the tab overlaps are consistent. The selected tab is always the
     // frontmost, but it's already been made frontmost when the tab was selected
     // so we don't need to do anything about it here. It will get put back into
     // place when another tab is selected.
+    // TODO(pinkerton): this doesn't seem to work in the case where a tab
+    // is opened between existing tabs. Disabling.
     if (![tab selected]) {
       [tabView_ addSubview:[tab view]
                 positioned:NSWindowBelow
                 relativeTo:previousTab];
     }
+#endif
     previousTab = [tab view];
 
     offset += NSWidth(tabFrame);
     offset -= kTabOverlap;
     i++;
   }
 
   NSRect newTabNewFrame = [newTabButton_ frame];
-  newTabNewFrame.origin =
-      NSMakePoint(MIN(availableWidth, offset + kNewTabButtonOffset), 0);
+  if ([self useFullWidthForLayout])
+    newTabNewFrame.origin =
+        NSMakePoint(MIN(availableWidth, offset + kNewTabButtonOffset), 0);
+  else
+    newTabNewFrame.origin = NSMakePoint(offset + kNewTabButtonOffset, 0);
   newTabNewFrame.origin.x = MAX(newTabNewFrame.origin.x,
                                 NSMaxX(placeholderFrame_));
   if (i > 0 && [newTabButton_ isHidden]) {
     id target = animate ? [newTabButton_ animator] : newTabButton_;
     [target setHidden:NO];
   }
 
   if (!NSEqualRects(newTabTargetFrame_, newTabNewFrame)) {
     [newTabButton_ setFrame:newTabNewFrame];
     newTabTargetFrame_ = newTabNewFrame;
@@ skipping 53 matching lines @@
   // a little better that just sliding over (maybe?).
   [newView setFrame:NSOffsetRect([newView frame],
                                  0, -[[self class] defaultTabHeight])];
 
   [tabView_ addSubview:newView
             positioned:inForeground ? NSWindowAbove : NSWindowBelow
             relativeTo:nil];
 
   [self setTabTitle:newController withContents:contents];
 
+  // If a tab is being inserted, we can again use the entire tab strip width
+  // for layout.
+  availableResizeWidth_ = kUseFullAvailableWidth;
+
   // We don't need to call |-layoutTabs| if the tab will be in the foreground
   // because it will get called when the new tab is selected by the tab model.
   if (!inForeground) {
     [self layoutTabs];
   }
 
   // Send a broadcast that the number of tabs have changed.
   [[NSNotificationCenter defaultCenter]
       postNotificationName:kTabStripNumberOfTabsChanged
                     object:self];
@@ skipping 233 matching lines @@
 }
 
 // Called when the tab strip view changes size. As we only registered for
 // changes on our view, we know it's only for our view. Layout w/out
 // animations since they are blocked by the resize nested runloop. We need
 // the views to adjust immediately.
 - (void)tabViewFrameChanged:(NSNotification*)info {
   [self layoutTabsWithAnimation:NO];
 }
 
+- (BOOL)useFullWidthForLayout {
+  return availableResizeWidth_ == kUseFullAvailableWidth;
+}
+
+// Call to install a tracking area that reports mouseEnter/Exit messages so
+// we can track when the mouse leaves the tab view after closing a tab with
+// the mouse. Don't install another tracking rect if one is already there.
+- (void)installTrackingArea {
+  if (closeTabTrackingArea_.get())
+    return;
+  // Note that we pass |NSTrackingInVisibleRect| so the rect is actually
+  // ignored.
+  closeTabTrackingArea_.reset([[NSTrackingArea alloc]
+      initWithRect:[tabView_ bounds]
+           options:NSTrackingMouseEnteredAndExited | NSTrackingActiveAlways |
+                    NSTrackingInVisibleRect
+             owner:self
+          userInfo:nil]);
+  [tabView_ addTrackingArea:closeTabTrackingArea_.get()];
+}
+
+- (void)mouseEntered:(NSEvent*)event {
+  // Do nothing.
+}
+
+// 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 {
+  [tabView_ removeTrackingArea:closeTabTrackingArea_.get()];
+  closeTabTrackingArea_.reset(nil);
+  availableResizeWidth_ = kUseFullAvailableWidth;
+  [self layoutTabs];
+}
+
 @end