Vertical scrolling arrows in bookmark bar folder windows when needed....

chrome/browser/cocoa/bookmark_bar_folder_controller.mm

 // Copyright (c) 2010 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/bookmark_bar_folder_controller.h"
 #include "base/mac_util.h"
+#include "base/nsimage_cache_mac.h"
 #include "base/sys_string_conversions.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/bookmarks/bookmark_utils.h"
 #import "chrome/browser/browser_theme_provider.h"
 #import "chrome/browser/cocoa/bookmark_bar_constants.h"  // namespace bookmarks
 #import "chrome/browser/cocoa/bookmark_bar_controller.h" // namespace bookmarks
 #import "chrome/browser/cocoa/bookmark_bar_folder_view.h"
 #import "chrome/browser/cocoa/bookmark_bar_folder_button_cell.h"
 #import "chrome/browser/cocoa/bookmark_bar_folder_hover_state.h"
 #import "chrome/browser/cocoa/bookmark_folder_target.h"
@@ skipping 16 matching lines @@
     1 * (bookmarks::kBookmarkButtonHeight +
          bookmarks::kBookmarkVerticalPadding);
 
 // Our NSScrollView is supposed to be just barely big enough to fit its
 // contentView.  It is actually a hair too small.
 // This turns on horizontal scrolling which, although slight, is awkward.
 // Make sure our window (and NSScrollView) are wider than its documentView
 // by at least this much.
 const CGFloat kScrollViewContentWidthMargin = 2;
 
-
 // When constraining a scrolling bookmark bar folder window to the
 // screen, shrink the "constrain" by this much vertically.  Currently
 // this is 0.0 to avoid a problem with tracking areas leaving the
 // window, but should probably be 8.0 or something.
 // TODO(jrg): http://crbug.com/36225
 const CGFloat kScrollWindowVerticalMargin = 0.0;
 
 }  // namespace
 
 @interface BookmarkBarFolderController(Private)
 - (void)configureWindow;
 - (void)addOrUpdateScrollTracking;
 - (void)removeScrollTracking;
 - (void)endScroll;
 - (void)addScrollTimerWithDelta:(CGFloat)delta;
 
 // Determine the best button width (which will be the widest button or the
 // maximum allowable button width, whichever is less) and resize all buttons.
 // Return the new width (so that the window can be adjusted, if necessary).
 - (CGFloat)adjustButtonWidths;
 
+// Show or hide the scroll arrows at the top/bottom of the window.
+- (void)showOrHideScrollArrows;
+
 @end
 
 @implementation BookmarkBarFolderController
 
 - (id)initWithParentButton:(BookmarkButton*)button
           parentController:(BookmarkBarFolderController*)parentController
              barController:(BookmarkBarController*)barController {
   NSString* nibPath =
       [mac_util::MainAppBundle() pathForResource:@"BookmarkBarFolderWindow"
                                           ofType:@"nib"];
   if ((self = [super initWithWindowNibPath:nibPath owner:self])) {
     parentButton_.reset([button retain]);
     parentController_.reset([parentController retain]);
     barController_ = barController;  // WEAK
     buttons_.reset([[NSMutableArray alloc] init]);
     folderTarget_.reset([[BookmarkFolderTarget alloc] initWithController:self]);
+    NSImage* image = nsimage_cache::ImageNamed(@"menu_overflow_up.pdf");
+    DCHECK(image);
+    verticalScrollArrowHeight_ = [image size].height;
     [self configureWindow];
     hoverState_.reset([[BookmarkBarFolderHoverState alloc] init]);
     if (scrollable_)
       [self addOrUpdateScrollTracking];
   }
   return self;
 }
 
 - (void)dealloc {
   [self removeScrollTracking];
@@ skipping 236 matching lines @@
   if (!NSContainsRect(screenFrame, windowFrame)) {
     scrollable_ = YES;
     windowFrame = NSIntersectionRect(screenFrame, windowFrame);
   }
   [[self window] setFrame:windowFrame display:YES];
   if (scrollable_) {
     [mainView_ scrollPoint:NSMakePoint(0, (NSHeight(mainViewFrame) -
                                            NSHeight(windowFrame)))];
   }
 
+  // If scrollable, show the arrows.
+  if (scrollable_) {
+    [self showOrHideScrollArrows];
+  }
+
   // Finally pop me up.
   [self configureWindowLevel];
 }
 
 - (void)offsetFolderMenuWindow:(NSSize)offset {
   NSWindow* window = [self window];
   NSRect windowFrame = [window frame];
   windowFrame.origin.x -= offset.width;
   windowFrame.origin.y += offset.height;  // Yes, in the opposite direction!
   [window setFrame:windowFrame display:YES];
@@ skipping 10 matching lines @@
   // Things look and feel more menu-like if all the buttons are the
   // full width of the window, especially if there are submenus.
   for (BookmarkButton* button in buttons_.get()) {
     NSRect buttonFrame = [button frame];
     buttonFrame.size.width = width;
     [button setFrame:buttonFrame];
   }
   return width;
 }
 
+- (BOOL)canScrollUp {
+  // If removal of an arrow would make things "finished", state as
+  // such.
+  CGFloat scrollY = [scrollView_ documentVisibleRect].origin.y;
+  if (scrollUpArrowShown_)
+    scrollY -= verticalScrollArrowHeight_;
+
+  if (scrollY <= 0)
+    return NO;
+  return YES;
+}
+
+- (BOOL)canScrollDown {
+  CGFloat arrowAdjustment = 0.0;
+
+  // We do NOT adjust based on the scrollDOWN arrow.  This keeps
+  // things from "jumping"; if removal of the down arrow (at the top
+  // of the window) would cause a scroll to end, we'll end.
+  if (scrollUpArrowShown_)
+    arrowAdjustment += verticalScrollArrowHeight_;
+
+  NSPoint scrollPosition = [scrollView_ documentVisibleRect].origin;
+  NSRect documentRect = [[scrollView_ documentView] frame];
+
+  // If we are exactly the right height, return no.  We need this
+  // extra conditional in the case where we've just scrolled/grown
+  // into position.
+  if (NSHeight([[self window] frame]) == NSHeight(documentRect))
+    return NO;
+
+  if ((scrollPosition.y + NSHeight([[self window] frame])) >=
+      (NSHeight(documentRect) + arrowAdjustment)) {
+    return NO;
+  }
+  return YES;
+}
+
+- (void)showOrHideScrollArrows {
+  NSRect frame = [scrollView_ frame];
+  CGFloat scrollDelta = 0.0;
+  BOOL canScrollDown = [self canScrollDown];
+  BOOL canScrollUp = [self canScrollUp];
+
+  if (canScrollUp != scrollUpArrowShown_) {
+    if (scrollUpArrowShown_) {
+      frame.origin.y -= verticalScrollArrowHeight_;
+      frame.size.height += verticalScrollArrowHeight_;
+      scrollDelta = verticalScrollArrowHeight_;
+    } else {
+      frame.origin.y += verticalScrollArrowHeight_;
+      frame.size.height -= verticalScrollArrowHeight_;
+      scrollDelta = -verticalScrollArrowHeight_;
+    }
+  }
+  if (canScrollDown != scrollDownArrowShown_) {
+    if (scrollDownArrowShown_) {
+      frame.size.height += verticalScrollArrowHeight_;
+    } else {
+      frame.size.height -= verticalScrollArrowHeight_;
+    }
+  }
+  scrollUpArrowShown_ = canScrollUp;
+  scrollDownArrowShown_ = canScrollDown;
+  [scrollView_ setFrame:frame];
+
+  // Adjust scroll based on new frame.  For example, if we make room
+  // for an arrow at the bottom, adjust the scroll so the topmost item
+  // is still fully visible.
+  if (scrollDelta) {
+    NSPoint scrollPosition = [scrollView_ documentVisibleRect].origin;
+    scrollPosition.y -= scrollDelta;
+    [[scrollView_ documentView] scrollPoint:scrollPosition];
+  }
+}
+
 #pragma mark BookmarkButtonControllerProtocol
 
 - (void)addButtonForNode:(const BookmarkNode*)node
                  atIndex:(NSInteger)buttonIndex {
   if (buttonIndex == -1)
     buttonIndex = [buttons_ count];
 
   // Remember the last moved button's frame or the default.
   NSRect buttonFrame = NSMakeRect(bookmarks::kBookmarkHorizontalPadding,
       NSHeight([mainView_ frame]) + bookmarks::kBookmarkBarHeight +
@@ skipping 175 matching lines @@
   if (delta) {
     // If we can, grow the window (up).
     if (NSHeight(windowFrame) < screenHeightMinusMargin) {
       CGFloat growAmount = delta;
       // Don't scroll more than enough to "finish".
       if (scrollPosition.y < 0)
         growAmount += scrollPosition.y;
       windowFrame.size.height += growAmount;
       windowFrame.size.height = std::min(NSHeight(windowFrame),
                                          screenHeightMinusMargin);
+      // Watch out for a finish that isn't the full height of the screen.
+      // We get here if using the scroll wheel to scroll by small amounts.
+      windowFrame.size.height = std::min(NSHeight(windowFrame),
+                                         NSHeight([mainView_ frame]));
       // Don't allow scrolling to make the window smaller, ever.  This
       // conditional is important when processing scrollWheel events.
       if (windowFrame.size.height > [[self window] frame].size.height) {
         [[self window] setFrame:windowFrame display:YES];
         [self addOrUpdateScrollTracking];
       }
     }
   }
 
   // If we're at either end, happiness.
   if ((scrollPosition.y <= 0) ||
       ((scrollPosition.y + NSHeight(windowFrame) >=
         NSHeight([mainView_ frame])) &&
        (windowFrame.size.height == screenHeightMinusMargin))) {
     [self endScroll];
 
-    // If the entire view is now visible the window is no longer scrollable.
-    if (NSHeight([mainView_ visibleRect]) == NSHeight([mainView_ bounds])) {
+    // If we can't scroll either up or down we are completely done.
+    // For example, perhaps we've scrolled a little and grown the
+    // window on-screen until there is now room for everything.
+    if (![self canScrollUp] && ![self canScrollDown]) {
       scrollable_ = NO;
       [self removeScrollTracking];
     }
   }
+
+  [self showOrHideScrollArrows];
 }
 
 // Perform a scroll of the window on the screen.
 // Called by a timer when scrolling.
 - (void)performScroll:(NSTimer*)timer {
   DCHECK(verticalScrollDelta_);
   [self performOneScroll:verticalScrollDelta_];
 }
 
 
@@ skipping 491 matching lines @@
 - (IBAction)openBookmarkInNewForegroundTab:(id)sender {
   [barController_ openBookmarkInNewForegroundTab:sender];
 }
 
 - (IBAction)openBookmarkInNewWindow:(id)sender {
   [barController_ openBookmarkInNewWindow:sender];
 }
 
 
 @end  // BookmarkBarFolderController