Mac fullscreen mode (with pkasting).

chrome/browser/cocoa/bookmark_bar_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 "base/sys_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/browser.h"
 #include "chrome/browser/browser_list.h"
 #import "chrome/browser/cocoa/bookmark_bar_bridge.h"
 #import "chrome/browser/cocoa/bookmark_bar_controller.h"
 #import "chrome/browser/cocoa/bookmark_bar_view.h"
 #import "chrome/browser/cocoa/bookmark_button_cell.h"
 #include "chrome/browser/profile.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 #include "skia/ext/skia_utils_mac.h"
 
 @interface BookmarkBarController(Private)
-- (void)applyContentAreaOffset:(BOOL)apply;
+- (void)applyContentAreaOffset:(BOOL)apply immediately:(BOOL)immediately;
 - (void)positionBar;
-- (void)showBookmarkBar:(BOOL)enable;
+- (void)showBookmarkBar:(BOOL)enable immediately:(BOOL)immediately;
 @end
 
 namespace {
 const int kBookmarkBarHeight = 30;
 // Magic numbers from Cole
 const CGFloat kDefaultBookmarkWidth = 150.0;
 const CGFloat kBookmarkVerticalPadding = 2.0;
 const CGFloat kBookmarkHorizontalPadding = 8.0;
 };
 
 @implementation BookmarkBarController
 
 - (id)initWithProfile:(Profile*)profile
           contentView:(NSView*)content
              delegate:(id<BookmarkURLOpener>)delegate {
   if ((self = [super init])) {
     bookmarkModel_ = profile->GetBookmarkModel();
     contentView_ = content;
     delegate_ = delegate;
+    // Be sure to enable the bar before trying to show it...
+    barIsEnabled_ = YES;
     // Create and initialize the view's position. Show it if appropriate.
     // TODO(jrg): put it in a nib if necessary.
     NSRect frame = NSMakeRect(0, 0, 0, 30);
     bookmarkBarView_ = [[BookmarkBarView alloc] initWithFrame:frame];
     [self positionBar];
-    if (profile->GetPrefs()->GetBoolean(prefs::kShowBookmarkBar))
-      [self showBookmarkBar:YES];
+    preferences_ = profile->GetPrefs();
+    if (preferences_->GetBoolean(prefs::kShowBookmarkBar))
+      [self showBookmarkBar:YES immediately:NO];
     [[[contentView_ window] contentView] addSubview:bookmarkBarView_];
   }
   // Don't pass ourself along until our init is done.
   // Thus, this call is (almost) last.
   bridge_.reset(new BookmarkBarBridge(self, bookmarkModel_));
   return self;
 }
 
 - (void)dealloc {
   [bookmarkBarView_ release];
   [super dealloc];
 }
 
 // Initializes the bookmark bar at the top edge of |contentArea_| and the
 // view's visibility to match the pref. This doesn't move the content view at
 // all, you need to call |-showBookmarkBar:| to do that.
 - (void)positionBar {
   // Hide or show bar based on initial visibility and set the resize flags.
   [bookmarkBarView_ setAutoresizingMask:NSViewWidthSizable | NSViewMinYMargin];
-  [bookmarkBarView_ setHidden:!barIsVisible_];
+  [bookmarkBarView_ setHidden:!barShouldBeShown_];
 
   // Set the bar's height to zero and position it at the top of the
   // content area, within the window's content view (as opposed to the
   // tab strip, which is a sibling). We'll enlarge it and slide the
   // content area down when we need to show this strip.
   NSRect contentFrame = [contentView_ frame];
   NSRect barFrame = NSMakeRect(0, NSMaxY(contentFrame),
                                contentFrame.size.width, 0);
   [bookmarkBarView_ setFrame:barFrame];
 }
 
 // Called when the contentView's frame changes.  Enlarge the view to
 // stay with the top of the contentView.
 - (void)resizeBookmarkBar {
   NSRect barFrame = [bookmarkBarView_ frame];
   const int maxY = NSMaxY(barFrame);
   barFrame.origin.y = NSMaxY([contentView_ frame]);
   barFrame.size.height = maxY - barFrame.origin.y;
   [bookmarkBarView_ setFrame:barFrame];
 }
 
-// Show or hide the bar based on the value of |enable|. Handles animating the
-// resize of the content view.
-- (void)showBookmarkBar:(BOOL)enable {
-  contentViewHasOffset_ = enable;
-  [bookmarkBarView_ setHidden:enable ? NO : YES];
-  [self applyContentAreaOffset:enable];
-
-  barIsVisible_ = enable;
-  if (enable) {
-    [self loaded:bookmarkModel_];
+// Show or hide the bar based on the value of |show|. Handles
+// animating the resize of the content view.  if |immediately| is YES,
+// make changes immediately instead of using an animator.  If the bar
+// is disabled, do absolutely nothing.  The routine which enables the
+// bar will show it if relevant using other mechanisms (the pref) to
+// determine desired state.
+- (void)showBookmarkBar:(BOOL)show immediately:(BOOL)immediately {
+  if (barIsEnabled_) {
+    contentViewHasOffset_ = show;
+    [bookmarkBarView_ setHidden:show ? NO : YES];
+    [self applyContentAreaOffset:show immediately:immediately];
+    barShouldBeShown_ = show;
+    if (show) {
+      [self loaded:bookmarkModel_];
+    }
   }
 }
 
 // Apply a contents box offset to make (or remove) room for the
 // bookmark bar.  If apply==YES, always make room (the contentView_ is
 // "full size").  If apply==NO we are trying to undo an offset.  If no
 // offset there is nothing to undo.
-- (void)applyContentAreaOffset:(BOOL)apply {
+- (void)applyContentAreaOffset:(BOOL)apply immediately:(BOOL)immediately {
   if (bookmarkBarView_ == nil) {
     // We're too early, but awakeFromNib will call me again.
     return;
   }
   if (!contentViewHasOffset_ && apply) {
     // There is no offset to unconditionally apply.
     return;
   }
 
   NSRect frame = [contentView_ frame];
   if (apply)
     frame.size.height -= kBookmarkBarHeight;
   else
     frame.size.height += kBookmarkBarHeight;
 
-  [[contentView_ animator] setFrame:frame];
+  if (immediately) {
+    [contentView_ setFrame:frame];
+    [contentView_ setNeedsDisplay:YES];
+  } else {
+    [[contentView_ animator] setFrame:frame];
+  }
+
   [bookmarkBarView_ setNeedsDisplay:YES];
   [contentView_ setNeedsDisplay:YES];
 }
 
 - (BOOL)isBookmarkBarVisible {
-  return barIsVisible_;
+  return barShouldBeShown_;
 }
 
 // We don't change a preference; we only change visibility.
 // Preference changing (global state) is handled in
 // BrowserWindowCocoa::ToggleBookmarkBar().
 - (void)toggleBookmarkBar {
-  [self showBookmarkBar:!barIsVisible_];
+  [self showBookmarkBar:!barShouldBeShown_ immediately:NO];
+}
+
+- (void)setBookmarkBarEnabled:(BOOL)enabled {
+  if (enabled) {
+    // Enabling the bar; set enabled then show if needed.
+    barIsEnabled_ = YES;
+    if (preferences_->GetBoolean(prefs::kShowBookmarkBar))
+      [self showBookmarkBar:YES immediately:YES];
+  } else {
+    // Disabling the bar; hide if visible.
+    if ([self isBookmarkBarVisible]) {
+      [self showBookmarkBar:NO immediately:YES];
+    }
+    barIsEnabled_ = NO;
+  }
 }
 
 // Delete all items from the bookmark bar.
 - (void)clearBookmarkBar {
   [bookmarkBarView_ setSubviews:[NSArray array]];
 }
 
 // TODO(jrg): add an openBookmarkInBackground() for ctrl-click which
 // has a different disposition.
 - (void)openBookmark:(id)sender {
@@ skipping 97 matching lines @@
       [button setToolTip:tooltip];
     }
     // Finally, add it to the bookmark bar.
     [bookmarkBarView_ addSubview:button];
   }
 }
 
 // TODO(jrg): for now this is brute force.
 - (void)loaded:(BookmarkModel*)model {
   DCHECK(model == bookmarkModel_);
-  // Do nothing if not visible or too early
-  if ((barIsVisible_ == NO) || !model->IsLoaded())
+  // Do nothing if not active or too early
+  if ((barShouldBeShown_ == NO) || !model->IsLoaded())
     return;
   // Else brute force nuke and build.
   const BookmarkNode* node = model->GetBookmarkBarNode();
   [self clearBookmarkBar];
   [self addNodesToBar:node];
 }
 
 - (void)beingDeleted:(BookmarkModel*)model {
   [self clearBookmarkBar];
 }
@@ skipping 41 matching lines @@
 - (void)nodeChildrenReordered:(BookmarkModel*)model
                          node:(const BookmarkNode*)node {
   [self loaded:model];
 }
 
 - (NSView*)view {
   return bookmarkBarView_;
 }
 
 @end