Updates to clean up default theme and add hover states

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 29 matching lines @@
 // A simple view class that prevents the windowserver from dragging the
 // area behind tabs. Sometimes core animation confuses it.
 @interface TabStripControllerDragBlockingView : NSView
 @end
 @implementation TabStripControllerDragBlockingView
 - (BOOL)mouseDownCanMoveWindow {return NO;}
 - (void)drawRect:(NSRect)rect {}
 @end
 
 @interface TabStripController(Private)
-- (void)installTrackingArea;
 - (BOOL)useFullWidthForLayout;
 - (void)addSubviewToPermanentList:(NSView*)aView;
 - (void)regenerateSubviewList;
 - (NSInteger)indexForContentsView:(NSView*)view;
 - (void)updateFavIconForContents:(TabContents*)contents
                          atIndex:(NSInteger)index;
 @end
 
 @implementation TabStripController
 
 - (id)initWithView:(TabStripView*)view
         switchView:(NSView*)switchView
            browser:(Browser*)browser {
   DCHECK(view && switchView && browser);
   if ((self = [super init])) {
-    tabView_ = view;
+    tabView_.reset([view retain]);
     switchView_ = switchView;
     browser_ = browser;
     tabModel_ = browser_->tabstrip_model();
     bridge_.reset(new TabStripModelObserverBridge(tabModel_, self));
     tabContentsArray_.reset([[NSMutableArray alloc] init]);
     tabArray_.reset([[NSMutableArray alloc] init]);
     permanentSubviews_.reset([[NSMutableArray alloc] init]);
 
     // Take the only child view present in the nib as the new tab button. For
     // some reason, if the view is present in the nib apriori, 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_ = [[tabView_ subviews] objectAtIndex:0];
     DCHECK([newTabButton_ isKindOfClass:[NSButton class]]);
     [self addSubviewToPermanentList:newTabButton_];
     [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]);
     [self addSubviewToPermanentList:dragBlockingView_];
     newTabTargetFrame_ = NSMakeRect(0, 0, 0, 0);
     availableResizeWidth_ = kUseFullAvailableWidth;
 
     // Install the permanent subviews.
     [self regenerateSubviewList];
 
     // 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_];
+
+    trackingArea_.reset([[NSTrackingArea alloc]
+        initWithRect:NSZeroRect  // Ignored by NSTrackingInVisibleRect
+             options:NSTrackingMouseEnteredAndExited |
+                     NSTrackingMouseMoved |
+                     NSTrackingActiveAlways |
+                     NSTrackingInVisibleRect
+               owner:self
+            userInfo:nil]);
+    [tabView_ addTrackingArea:trackingArea_.get()];
   }
   return self;
 }
 
 - (void)dealloc {
-  if (closeTabTrackingArea_.get())
-    [tabView_ removeTrackingArea:closeTabTrackingArea_.get()];
+  if (trackingArea_.get())
+    [tabView_ removeTrackingArea:trackingArea_.get()];
   [[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.
@@ skipping 102 matching lines @@
   DCHECK([sender isKindOfClass:[NSView class]]);
   int index = [self indexForTabView:sender];
   if (index >= 0 && tabModel_->ContainsIndex(index))
     tabModel_->SelectTabContentsAt(index, true);
 }
 
 // Called when the user closes a tab. Asks the model to close the tab. |sender|
 // is the TabView that is potentially going away.
 - (void)closeTab:(id)sender {
   DCHECK([sender isKindOfClass:[NSView class]]);
+  if ([hoveredTab_ isEqual:sender]) {
+    hoveredTab_ = nil;
+  }
   int index = [self indexForTabView:sender];
   if (tabModel_->ContainsIndex(index)) {
     TabContents* contents = tabModel_->GetTabContentsAt(index);
     if (contents)
       UserMetrics::RecordAction(L"CloseTab_Mouse", contents->profile());
     if ([self numberOfTabViews] > 1) {
       // Limit the width available for laying out tabs so that tabs are not
       // resized until a later time (when the mouse leaves the tab strip).
       // TODO(pinkerton): re-visit when handling tab overflow.
       NSView* penultimateTab = [self viewAtIndex:[tabArray_ count] - 2];
       availableResizeWidth_ = NSMaxX([penultimateTab frame]);
-      [self installTrackingArea];
       tabModel_->CloseTabContentsAt(index);
     } else {
       // Use the standard window close if this is the last tab
       // this prevents the tab from being removed from the model until after
       // the window dissapears
       [[tabView_ window] performClose:nil];
     }
   }
 }
 
@@ skipping 74 matching lines @@
 
   CGFloat minX = NSMinX(placeholderFrame_);
   BOOL visible = [[tabView_ window] isVisible];
 
   float offset = kIndentLeavingSpaceForControls;
   NSUInteger i = 0;
   NSInteger gap = -1;
   for (TabController* tab in tabArray_.get()) {
     BOOL isPlaceholder = [[tab view] isEqual:placeholderTab_];
     NSRect tabFrame = [[tab view] frame];
-    tabFrame.size.height = [[self class] defaultTabHeight];
+    tabFrame.size.height = [[self class] defaultTabHeight] + 1;
     tabFrame.origin.y = 0;
     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];
     }
 
@@ skipping 207 matching lines @@
   // Release the tab contents controller so those views get destroyed. This
   // will remove all the tab content Cocoa views from the hierarchy. A
   // subsequent "select tab" notification will follow from the model. To
   // tell us what to swap in in its absence.
   [tabContentsArray_ removeObjectAtIndex:index];
 
   // Remove the |index|th view from the tab strip
   NSView* tab = [self viewAtIndex:index];
   [tab removeFromSuperview];
 
+  if ([hoveredTab_ isEqual:tab]) {
+    hoveredTab_ = nil;
+  }
+
   NSValue *identifier = [NSValue valueWithPointer:tab];
   [targetFrames_ removeObjectForKey:identifier];
 
   // Once we're totally done with the tab, delete its controller
   [tabArray_ removeObjectAtIndex:index];
 
   // Send a broadcast that the number of tabs have changed.
   [[NSNotificationCenter defaultCenter]
       postNotificationName:kTabStripNumberOfTabsChanged
                     object:self];
@@ skipping 164 matching lines @@
 // is no placeholder, it will go at the end. Used when dragging from another
 // window when we don't have access to the TabContents as part of our strip.
 - (void)dropTabContents:(TabContents*)contents {
   int index = [self indexOfPlaceholder];
 
   // Insert it into this tab strip. We want it in the foreground and to not
   // inherit the current tab's group.
   tabModel_->InsertTabContentsAt(index, contents, true, false);
 }
 
-- (void)userChangedTheme {
+- (void)applyTheme {
   for (TabController* tab in tabArray_.get()) {
-    [[tab view] setNeedsDisplay:YES];
+    [tab applyTheme];
   }
 }
 
 // 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. Neither the tabs nor their z-order are
 // changed, so we don't need to update the subviews.
 - (void)tabViewFrameChanged:(NSNotification*)info {
   [self layoutTabsWithAnimation:NO regenerateSubviews:NO];
 }
 
 - (BOOL)useFullWidthForLayout {
   return availableResizeWidth_ == kUseFullAvailableWidth;
 }
 
-// Call to install a tracking area that reports mouseEnter/Exit messages so
-// we can track when the mouse leaves the tab view after closing a tab with
-// the mouse. Don't install another tracking rect if one is already there.
-- (void)installTrackingArea {
-  if (closeTabTrackingArea_.get())
-    return;
-  // Note that we pass |NSTrackingInVisibleRect| so the rect is actually
-  // ignored.
-  closeTabTrackingArea_.reset([[NSTrackingArea alloc]
-      initWithRect:[tabView_ bounds]
-           options:NSTrackingMouseEnteredAndExited | NSTrackingActiveAlways |
-                    NSTrackingInVisibleRect
-             owner:self
-          userInfo:nil]);
-  [tabView_ addTrackingArea:closeTabTrackingArea_.get()];
+- (void)mouseMoved:(NSEvent *)event {
+  // Use hit test to figure out what view we are hovering over.
+  TabView* targetView = (TabView*)[tabView_ hitTest:[event locationInWindow]];
+  if (![targetView isKindOfClass:[TabView class]]) {
+    if ([[targetView superview] isKindOfClass:[TabView class]]) {
+      targetView = (TabView*)[targetView superview];
+    } else {
+      targetView = nil;
+    }
+  }
+
+  if (hoveredTab_ != targetView) {
+    [hoveredTab_ mouseExited:nil];  // We don't pass event because moved events
+    [targetView mouseEntered:nil];  // don't have valid tracking areas
+    hoveredTab_ = targetView;
+  } else {
+    [hoveredTab_ mouseMoved:event];
+  }
 }
 
 - (void)mouseEntered:(NSEvent*)event {
-  // Do nothing.
+  [self mouseMoved:event];
 }
 
 // Called when the tracking area is in effect which means we're tracking to
 // see if the user leaves the tab strip with their mouse. When they do,
 // reset layout to use all available width.
 - (void)mouseExited:(NSEvent*)event {
-  [tabView_ removeTrackingArea:closeTabTrackingArea_.get()];
-  closeTabTrackingArea_.reset(nil);
   availableResizeWidth_ = kUseFullAvailableWidth;
+
+  [hoveredTab_ mouseExited:event];
+  hoveredTab_ = nil;
   [self layoutTabs];
 }
 
 // Adds the given subview to (the end of) the list of permanent subviews
 // (specified from bottom up). These subviews will always be below the
 // transitory subviews (tabs). |-regenerateSubviewList| must be called to
 // effectuate the addition.
 - (void)addSubviewToPermanentList:(NSView*)aView {
   [permanentSubviews_ addObject:aView];
 }
@@ skipping 84 matching lines @@
   BrowserWindowController* controller =
       (BrowserWindowController*)[[switchView_ window] windowController];
   DCHECK(index >= 0);
   if (index >= 0) {
     [controller setTab:[self viewAtIndex:index] isDraggable:YES];
   }
 }
 
 
 @end