[Mac] Add support for growing or shrinking the window during animations....

chrome/browser/cocoa/browser_window_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.
 
 #include <Carbon/Carbon.h>
 
 #include "app/l10n_util_mac.h"
 #include "base/mac_util.h"
 #include "base/scoped_nsdisable_screen_updates.h"
 #import "base/scoped_nsobject.h"
@@ skipping 74 matching lines @@
 // Repositions the windows subviews.
 - (void)layoutSubviews;
 
 // Should we show the normal bookmark bar?
 - (BOOL)shouldShowBookmarkBar;
 
 // Is the current page one for which the bookmark should be shown detached *if*
 // the normal bookmark bar is not shown?
 - (BOOL)shouldShowDetachedBookmarkBar;
 
+// Sets the toolbar's height to a value appropriate for the given compression.
+// Also adjusts the bookmark bar's height by the opposite amount in order to
+// keep the total height of the two views constant.
+- (void)adjustToolbarAndBookmarkBarForCompression:(CGFloat)compression;
+
 @end
 
 
 @implementation BrowserWindowController
 
 // Load the browser window nib and do any Cocoa-specific initialization.
 // Takes ownership of |browser|. Note that the nib also sets this controller
 // up as the window's delegate.
 - (id)initWithBrowser:(Browser*)browser {
   return [self initWithBrowser:browser takeOwnership:YES];
 }
 
 // Private (TestingAPI) init routine with testing options.
 - (id)initWithBrowser:(Browser*)browser takeOwnership:(BOOL)ownIt {
   // Use initWithWindowNibPath:: instead of initWithWindowNibName: so we
   // can override it in a unit test.
   NSString* nibpath = [mac_util::MainAppBundle()
                         pathForResource:@"BrowserWindow"
                                  ofType:@"nib"];
   if ((self = [super initWithWindowNibPath:nibpath owner:self])) {
     DCHECK(browser);
+    initializing_ = YES;
     browser_.reset(browser);
     ownsBrowser_ = ownIt;
     tabObserver_.reset(
         new TabStripModelObserverBridge(browser->tabstrip_model(), self));
     NSWindow* window = [self window];
     windowShim_.reset(new BrowserWindowCocoa(browser, self, window));
 
 
     // Sets the window to not have rounded corners, which prevents
     // the resize control from being inset slightly and looking ugly.
@@ skipping 86 matching lines @@
                                          resizeDelegate:self]);
       [[[self window] contentView] addSubview:[extensionShelfController_ view]];
       [extensionShelfController_ wasInsertedIntoWindow];
     }
 
     // Force a relayout of all the various bars.
     [self layoutSubviews];
 
     // Create the bridge for the status bubble.
     statusBubble_ = new StatusBubbleMac([self window], self);
+
+    // We are done initializing now.
+    initializing_ = NO;
   }
   return self;
 }
 
 - (void)dealloc {
   browser_->CloseAllTabs();
   [downloadShelfController_ exiting];
 
   // Under certain testing configurations we may not actually own the browser.
   if (ownsBrowser_ == NO)
@@ skipping 229 matching lines @@
   NSRect newScrIntersectCurFr = NSIntersectionRect([newScreen frame], curFrame);
   NSRect curScrIntersectCurFr = NSIntersectionRect([curScreen frame], curFrame);
   if (newScrIntersectCurFr.size.width*newScrIntersectCurFr.size.height >=
       (curScrIntersectCurFr.size.width*curScrIntersectCurFr.size.height - 1.0))
     return YES;
 
   // If it wasn't reasonable, return NO.
   return NO;
 }
 
+// Adjusts the window height by the given amount.
+- (void)adjustWindowHeightBy:(CGFloat)deltaH {
+  // By not adjusting the window height when initializing, we can ensure that
+  // the window opens with the same size that was saved on close.
+  if (initializing_ || [self isFullscreen] || deltaH == 0)
+    return;
+
+  NSWindow* window = [self window];
+  NSRect windowFrame = [window frame];
+  NSRect workarea = [[window screen] visibleFrame];
+
+  // If the window is not already fully in the workarea, do not adjust its frame
+  // at all.
+  if (!NSContainsRect(workarea, windowFrame))
+    return;
+
+  // If the window spans the full height of the current workspace, do not adjust
+  // its frame at all.
+  if (windowFrame.origin.y == workarea.origin.y &&
+      windowFrame.size.height == workarea.size.height)
+    return;
+
+  // Resize the window down until it hits the bottom of the workarea, then if
+  // needed continue resizing upwards.  Do not resize the window to be taller
+  // than the current workarea.
+  // Resize the window as requested, keeping the top left corner fixed.
+  windowFrame.origin.y -= deltaH;
+  windowFrame.size.height += deltaH;
+
+  // If the bottom left corner is now outside the visible frame, move the window
+  // up to make it fit, but make sure not to move the top left corner out of the
+  // visible frame.
+  if (windowFrame.origin.y < workarea.origin.y) {
+    windowFrame.origin.y = workarea.origin.y;
+    windowFrame.size.height =
+        std::min(windowFrame.size.height, workarea.size.height);
+  }
+
+  // Disable subview resizing while resizing the window, or else we will get
+  // unwanted renderer resizes.  The calling code must call layoutSubviews to
+  // make things right again.
+  NSView* contentView = [window contentView];
+  [contentView setAutoresizesSubviews:NO];
+  [window setFrame:windowFrame display:NO];
+  [contentView setAutoresizesSubviews:YES];
+}
+
 // Main method to resize browser window subviews.  This method should be called
 // when resizing any child of the content view, rather than resizing the views
 // directly.  If the view is already the correct height, does not force a
 // relayout.
 - (void)resizeView:(NSView*)view newHeight:(float)height {
   // We should only ever be called for one of the following four views.
   // |downloadShelfController_| may be nil. If we are asked to size the bookmark
   // bar directly, its superview must be this controller's content view.
   DCHECK(view);
   DCHECK(view == [toolbarController_ view] ||
          view == [infoBarContainerController_ view] ||
          view == [extensionShelfController_ view] ||
          view == [downloadShelfController_ view] ||
          view == [bookmarkBarController_ view]);
 
   // Change the height of the view and call |-layoutSubViews|. We set the height
   // here without regard to where the view is on the screen or whether it needs
   // to "grow up" or "grow down."  The below call to |-layoutSubviews| will
   // position each view correctly.
   NSRect frame = [view frame];
   if (frame.size.height == height)
     return;
 
+  // Grow or shrink the window by the amount of the height change.  We adjust
+  // the window height only in two cases:
+  // 1) We are adjusting the height of the bookmark bar and it is currently
+  // animating either open or closed.
+  // 2) We are adjusting the height of the download shelf.
+  //
+  // We do not adjust the window height for bookmark bar changes on the NTP.
+  BOOL shouldAdjustBookmarkHeight =
+      [bookmarkBarController_ isAnimatingBetweenState:bookmarks::kHiddenState
+                                             andState:bookmarks::kShowingState];
+  if ((shouldAdjustBookmarkHeight && view == [bookmarkBarController_ view]) ||
+      view == [downloadShelfController_ view]) {
+    [[self window] disableScreenUpdatesUntilFlush];
+    CGFloat deltaH = height - frame.size.height;
+    [self adjustWindowHeightBy:deltaH];
+  }
+
   frame.size.height = height;
   // TODO(rohitrao): Determine if calling setFrame: twice is bad.
   [view setFrame:frame];
   [self layoutSubviews];
 }
 
 - (void)setAnimationInProgress:(BOOL)inProgress {
   [[self tabContentArea] setFastResizeMode:inProgress];
 }
 
@@ skipping 716 matching lines @@
   if (statusBubble_) {
     statusBubble_->UpdateSizeAndPosition();
   }
 }
 
 // (Needed for |BookmarkBarControllerDelegate| protocol.)
 - (void)bookmarkBar:(BookmarkBarController*)controller
  didChangeFromState:(bookmarks::VisualState)oldState
             toState:(bookmarks::VisualState)newState {
   [toolbarController_
-      setHeightCompression:[controller getDesiredToolbarHeightCompression]];
-  [toolbarController_
       setDividerOpacity:[bookmarkBarController_ toolbarDividerOpacity]];
+  [self adjustToolbarAndBookmarkBarForCompression:
+          [controller getDesiredToolbarHeightCompression]];
 }
 
 // (Needed for |BookmarkBarControllerDelegate| protocol.)
 - (void)bookmarkBar:(BookmarkBarController*)controller
 willAnimateFromState:(bookmarks::VisualState)oldState
             toState:(bookmarks::VisualState)newState {
   [toolbarController_
-      setHeightCompression:[controller getDesiredToolbarHeightCompression]];
-  [toolbarController_
       setDividerOpacity:[bookmarkBarController_ toolbarDividerOpacity]];
+  [self adjustToolbarAndBookmarkBarForCompression:
+          [controller getDesiredToolbarHeightCompression]];
 }
 
 @end
 
 @implementation BrowserWindowController (Private)
 
 // If the browser is in incognito mode, install the image view to decorate
 // the window at the upper right. Use the same base y coordinate as the
 // tab strip.
 - (void)installIncognitoBadge {
@@ skipping 266 matching lines @@
   return browser_->profile()->GetPrefs()->GetBoolean(prefs::kShowBookmarkBar) ?
       YES : NO;
 }
 
 - (BOOL)shouldShowDetachedBookmarkBar {
   DCHECK(browser_.get());
   TabContents* contents = browser_->GetSelectedTabContents();
   return (contents && contents->ShouldShowBookmarkBar()) ? YES : NO;
 }
 
+- (void)adjustToolbarAndBookmarkBarForCompression:(CGFloat)compression {
+  CGFloat newHeight =
+      [toolbarController_ desiredHeightForCompression:compression];
+  NSRect toolbarFrame = [[toolbarController_ view] frame];
+  CGFloat deltaH = newHeight - toolbarFrame.size.height;
+
+  if (deltaH == 0)
+    return;
+
+  toolbarFrame.size.height = newHeight;
+  NSRect bookmarkFrame = [[bookmarkBarController_ view] frame];
+  bookmarkFrame.size.height = bookmarkFrame.size.height - deltaH;
+  [[toolbarController_ view] setFrame:toolbarFrame];
+  [[bookmarkBarController_ view] setFrame:bookmarkFrame];
+  [self layoutSubviews];
+}
+
 @end
 
 @implementation GTMTheme (BrowserThemeProviderInitialization)
 + (GTMTheme*)themeWithBrowserThemeProvider:(BrowserThemeProvider*)provider
                             isOffTheRecord:(BOOL)isOffTheRecord {
   // First check if it's in the cache.
   // TODO(pinkerton): This might be a good candidate for a singleton.
   typedef std::pair<std::string, BOOL> ThemeKey;
   static std::map<ThemeKey, GTMTheme*> cache;
   ThemeKey key(provider->GetThemeID(), isOffTheRecord);
@@ skipping 139 matching lines @@
   if (frameOverlayInactiveImage) {
     [theme setValue:frameOverlayInactiveImage
        forAttribute:@"overlay"
               style:GTMThemeStyleWindow
               state:GTMThemeStateInactiveWindow];
   }
 
   return theme;
 }
 @end