Live resize of tabs as the window resizes....

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 48 matching lines @@
     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);
+
+    // 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 {
+  [[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.
 - (void)swapInTabAtIndex:(NSInteger)index {
   TabContentsController* controller = [tabContentsArray_ objectAtIndex:index];
 
   // Resize the new view to fit the window. Calling |view| may lazily
@@ skipping 104 matching lines @@
                   yStretchiness:(CGFloat)yStretchiness {
   placeholderTab_ = tab;
   placeholderFrame_ = frame;
   placeholderStretchiness_ = yStretchiness;
   [self layoutTabs];
 }
 
 // Lay out all tabs in the order of their TabContentsControllers, which matches
 // the ordering in the TabStripModel. This call isn't that expensive, though
 // it is O(n) in the number of tabs. Tabs will animate to their new position
-// if the window is visible.
+// if the window is visible and |animate| is YES.
 // TODO(pinkerton): Handle drag placeholders via proxy objects, perhaps a
 // subclass of TabContentsController with everything stubbed out or by
 // abstracting a base class interface.
 // TODO(pinkerton): Note this doesn't do too well when the number of min-sized
 // tabs would cause an overflow.
-- (void)layoutTabs {
+- (void)layoutTabsWithAnimation:(BOOL)animate {
   const float kIndentLeavingSpaceForControls = 64.0;
   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];
@@ skipping 24 matching lines @@
     tabFrame.origin.x = offset;
 
     // If the tab is hidden, we consider it a new tab. We make it visible
     // and animate it in.
     BOOL newTab = [[tab view] isHidden];
     if (newTab) {
       [[tab view] setHidden:NO];
     }
 
     if (isPlaceholder) {
       // Move the current tab to the correct location intantly.

[rohitrao (ping after 24h), 2009/07/24 16:11:22]

Typo: intantly.

       // We need a duration or else it doesn't cancel an inflight animation.
       [NSAnimationContext beginGrouping];
       [[NSAnimationContext currentContext] setDuration:0.000001];
       tabFrame.origin.x = placeholderFrame_.origin.x;
       // TODO(alcor): reenable this
       //tabFrame.size.height += 10.0 * placeholderStretchiness_;
-      [[[tab view] animator] setFrame:tabFrame];
+      id target = animate ? [[tab view] animator] : [tab view];
+      [target setFrame:tabFrame];
       [NSAnimationContext endGrouping];
 
       // Store the frame by identifier to aviod redundant calls to animator.
       NSValue *identifier = [NSValue valueWithPointer:[tab view]];
       [targetFrames_ setObject:[NSValue valueWithRect:tabFrame]
                         forKey:identifier];
       continue;
     } else {
       // If our left edge is to the left of the placeholder's left, but our mid
       // is to the right of it we should slide over to make space for it.
       if (placeholderTab_ && gap < 0 && NSMidX(tabFrame) > minX) {
         gap = i;
         offset += NSWidth(tabFrame);
         offset -= kTabOverlap;
         tabFrame.origin.x = offset;
       }
 
       // Animate the tab in by putting it below the horizon.
-      if (newTab && visible) {
+      if (newTab && visible && animate) {
         [[tab view] setFrame:NSOffsetRect(tabFrame, 0, -NSHeight(tabFrame))];
       }
 
       // 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 selected] ? MAX(baseTabWidth, kMinSelectedTabWidth) :
                            baseTabWidth;
 
       // Check the frame by identifier to avoid redundant calls to animator.
-      id frameTarget = visible ? [[tab view] animator] : [tab view];
+      id frameTarget = visible && animate ? [[tab view] animator] : [tab view];

[TVL, 2009/07/24 16:27:03]

line 268 this was "target", here it's "frameTarget", any reason for different
naming of the same thing?

       NSValue *identifier = [NSValue valueWithPointer:[tab view]];
       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);
     }
@@ skipping 14 matching lines @@
     offset -= kTabOverlap;
     i++;
   }
 
   NSRect newTabNewFrame = [newTabButton_ frame];
   newTabNewFrame.origin =
       NSMakePoint(MIN(availableWidth, offset + kNewTabButtonOffset), 0);
   newTabNewFrame.origin.x = MAX(newTabNewFrame.origin.x,
                                 NSMaxX(placeholderFrame_));
   if (i > 0 && [newTabButton_ isHidden]) {
-    [[newTabButton_ animator] setHidden:NO];
+    id target = animate ? [newTabButton_ animator] : newTabButton_;
+    [target setHidden:NO];
   }
 
   if (!NSEqualRects(newTabTargetFrame_, newTabNewFrame)) {
     [newTabButton_ setFrame:newTabNewFrame];
     newTabTargetFrame_ = newTabNewFrame;
     // Move the new tab button into place.
   }
 
   [NSAnimationContext endGrouping];
   [dragBlockingView_ setFrame:enclosingRect];
 }
 
+// When we're told to layout from the public API we always want to animate.
+- (void)layoutTabs {
+  [self layoutTabsWithAnimation:YES];
+}
+
 // Handles setting the title of the tab based on the given |contents|. Uses
 // a canned string if |contents| is NULL.
 - (void)setTabTitle:(NSViewController*)tab withContents:(TabContents*)contents {
   NSString* titleString = nil;
   if (contents)
     titleString = base::SysUTF16ToNSString(contents->GetTitle());
   if (![titleString length]) {
     titleString =
       base::SysWideToNSString(
           l10n_util::GetString(IDS_BROWSER_WINDOW_MAC_TAB_UNTITLED));
@@ skipping 276 matching lines @@
   // inherit the current tab's group.
   tabModel_->InsertTabContentsAt(index, contents, true, false);
 }
 
 - (void)userChangedTheme {
   for (TabController* tab in tabArray_.get()) {
     [[tab view] setNeedsDisplay:YES];
   }
 }
 
+// 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];
+}
+
 @end