Fullscreen support for Lion.

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

 // Copyright (c) 2011 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 <limits>
 #include <string>
@@ skipping 79 matching lines @@
 
 // The amount by which tabs overlap.
 const CGFloat kTabOverlap = 20.0;
 
 // 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 kAvatarTabStripShrink = 18;
-
 // Time (in seconds) in which tabs animate to their final position.
 const NSTimeInterval kAnimationDuration = 0.125;
 
 // The amount by wich the profile menu button is offset (from tab tabs or new
 // tab button).
 const CGFloat kProfileMenuButtonOffset = 6.0;
 
 // 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 {
@@ skipping 188 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 indentForControls = indentForControls_;
+@synthesize leftIndentForControls = leftIndentForControls_;
+@synthesize rightIndentForControls = rightIndentForControls_;
 
 - (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]);
     switchView_ = switchView;
     browser_ = browser;
     tabStripModel_ = browser_->tabstrip_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]);
 
     defaultFavicon_.reset(
         [gfx::GetCachedImageWithName(@"nav.pdf") retain]);
 
-    [self setIndentForControls:[[self class] defaultIndentForControls]];
+    [self setLeftIndentForControls:[[self class] defaultLeftIndentForControls]];
+    [self setRightIndentForControls:0];
 
     // TODO(viettrungluu): WTF? "For some reason, if the view is present in the
     // nib a priori, 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_ = [view getNewTabButton];
     [self addSubviewToPermanentList:newTabButton_];
     [newTabButton_ setTarget:nil];
     [newTabButton_ setAction:@selector(commandDispatch:)];
     [newTabButton_ setTag:IDC_NEW_TAB];
 
@@ skipping 111 matching lines @@
     [[[view animationForKey:@"frameOrigin"] delegate] invalidate];
   }
   [[NSNotificationCenter defaultCenter] removeObserver:self];
   [super dealloc];
 }
 
 + (CGFloat)defaultTabHeight {
   return 25.0;
 }
 
-+ (CGFloat)defaultIndentForControls {
++ (CGFloat)defaultLeftIndentForControls {
   // Default indentation leaves enough room so tabs don't overlap with the
   // window controls.
   return 70.0;
 }
 
 // Finds the TabContentsController associated with the given index into the tab
 // model and swaps out the sole child of the contentArea to display its
 // contents.
 - (void)swapInTabAtIndex:(NSInteger)modelIndex {
   DCHECK(modelIndex >= 0 && modelIndex < tabStripModel_->count());
@@ skipping 300 matching lines @@
   placeholderStretchiness_ = yStretchiness;
   [self layoutTabsWithAnimation:initialLayoutComplete_ regenerateSubviews:NO];
 }
 
 - (BOOL)isDragSessionActive {
   return placeholderTab_ != nil;
 }
 
 - (BOOL)isTabFullyVisible:(TabView*)tab {
   NSRect frame = [tab frame];
-  return NSMinX(frame) >= [self indentForControls] &&
-      NSMaxX(frame) <= NSMaxX([tabStripView_ frame]);
+  return NSMinX(frame) >= [self leftIndentForControls] &&
+      NSMaxX(frame) <= (NSMaxX([tabStripView_ frame]) -
+                        [self rightIndentForControls]);
 }
 
 - (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 (verticalLayout_) {
     availableSpace = NSHeight([tabStripView_ bounds]);
   } else {
     if ([self inRapidClosureMode]) {
       availableSpace = availableResizeWidth_;
     } else {
       availableSpace = NSWidth([tabStripView_ frame]);
 
-      BrowserWindowController* controller =
-          (BrowserWindowController*)[[tabStripView_ window] windowController];
-
-      // Account for the widths of the new tab button or the avatar, if any/all
-      // are present.
+      // Account for the width of the new tab button.
       availableSpace -= NSWidth([newTabButton_ frame]) + kNewTabButtonOffset;
-      if ([controller respondsToSelector:@selector(shouldShowAvatar)] &&
-          [controller shouldShowAvatar]) {
-        availableSpace -= kAvatarTabStripShrink;
-      }
     }
-    availableSpace -= [self indentForControls];
+    availableSpace -= [self leftIndentForControls];
+    availableSpace -= [self rightIndentForControls];
   }
 
   // This may be negative, but that's okay (taken care of by |MAX()| when
   // calculating tab sizes). "mini" tabs in horizontal mode just get a special
   // 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;
   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;
 
     // Clamp the width between the max and min.
     nonMiniTabWidth = MAX(MIN(nonMiniTabWidth, kMaxTabWidth), kMinTabWidth);
   }
 
   BOOL visible = [[tabStripView_ window] isVisible];
 
-  CGFloat offset = [self indentForControls];
+  CGFloat offset = [self leftIndentForControls];
   bool hasPlaceholderGap = false;
   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] + 1;
     if (verticalLayout_) {
@@ skipping 141 matching lines @@
   // Mark that we've successfully completed layout of at least one tab.
   initialLayoutComplete_ = YES;
 }
 
 // When we're told to layout from the public API we usually want to animate,
 // except when it's the first time.
 - (void)layoutTabs {
   [self layoutTabsWithAnimation:initialLayoutComplete_ regenerateSubviews:YES];
 }
 
+- (void)layoutTabsWithoutAnimation {
+  [self layoutTabsWithAnimation:NO regenerateSubviews: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 = l10n_util::GetNSString(IDS_BROWSER_WINDOW_MAC_TAB_UNTITLED);
   }
   [tab setTitle:titleString];
@@ skipping 970 matching lines @@
   NSInteger index = [self indexFromModelIndex:modelIndex];
   BrowserWindowController* controller =
       (BrowserWindowController*)[[switchView_ window] windowController];
   DCHECK(index >= 0);
   if (index >= 0) {
     [controller setTab:[self viewAtIndex:index] isDraggable:YES];
   }
 }
 
 @end