src/chrome/browser/ui/cocoa/tabs/tab_controller.mm

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #import "chrome/browser/ui/cocoa/tabs/tab_controller.h"
   6
   7 #include <algorithm>
   8 #include <cmath>
   9
  10 #include "base/i18n/rtl.h"
  11 #include "base/mac/bundle_locations.h"
  12 #include "base/mac/mac_util.h"
  13 #import "chrome/browser/themes/theme_properties.h"
  14 #import "chrome/browser/themes/theme_service.h"
  15 #import "chrome/browser/ui/cocoa/sprite_view.h"
  16 #import "chrome/browser/ui/cocoa/tabs/media_indicator_view.h"
  17 #import "chrome/browser/ui/cocoa/tabs/tab_controller_target.h"
  18 #import "chrome/browser/ui/cocoa/tabs/tab_view.h"
  19 #import "chrome/browser/ui/cocoa/themed_window.h"
  20 #import "extensions/common/extension.h"
  21 #import "ui/base/cocoa/menu_controller.h"
  22
  23 @implementation TabController
  24
  25 @synthesize action = action_;
  26 @synthesize app = app_;
  27 @synthesize loadingState = loadingState_;
  28 @synthesize mini = mini_;
  29 @synthesize pinned = pinned_;
  30 @synthesize target = target_;
  31 @synthesize url = url_;
  32
  33 namespace TabControllerInternal {
  34
  35 // A C++ delegate that handles enabling/disabling menu items and handling when
  36 // a menu command is chosen. Also fixes up the menu item label for "pin/unpin
  37 // tab".
  38 class MenuDelegate : public ui::SimpleMenuModel::Delegate {
  39  public:
  40   explicit MenuDelegate(id<TabControllerTarget> target, TabController* owner)
  41       : target_(target),
  42         owner_(owner) {}
  43
  44   // Overridden from ui::SimpleMenuModel::Delegate
  45   virtual bool IsCommandIdChecked(int command_id) const OVERRIDE {
  46     return false;
  47   }
  48   virtual bool IsCommandIdEnabled(int command_id) const OVERRIDE {
  49     TabStripModel::ContextMenuCommand command =
  50         static_cast<TabStripModel::ContextMenuCommand>(command_id);
  51     return [target_ isCommandEnabled:command forController:owner_];
  52   }
  53   virtual bool GetAcceleratorForCommandId(
  54       int command_id,
  55       ui::Accelerator* accelerator) OVERRIDE { return false; }
  56   virtual void ExecuteCommand(int command_id, int event_flags) OVERRIDE {
  57     TabStripModel::ContextMenuCommand command =
  58         static_cast<TabStripModel::ContextMenuCommand>(command_id);
  59     [target_ commandDispatch:command forController:owner_];
  60   }
  61
  62  private:
  63   id<TabControllerTarget> target_;  // weak
  64   TabController* owner_;  // weak, owns me
  65 };
  66
  67 }  // TabControllerInternal namespace
  68
  69 // The min widths is the smallest number at which the right edge of the right
  70 // tab border image is not visibly clipped.  It is a bit smaller than the sum
  71 // of the two tab edge bitmaps because these bitmaps have a few transparent
  72 // pixels on the side.  The selected tab width includes the close button width.
  73 + (CGFloat)minTabWidth { return 36; }
  74 + (CGFloat)minActiveTabWidth { return 52; }
  75 + (CGFloat)maxTabWidth { return 214; }
  76 + (CGFloat)miniTabWidth { return 58; }
  77 + (CGFloat)appTabWidth { return 66; }
  78
  79 - (TabView*)tabView {
  80   DCHECK([[self view] isKindOfClass:[TabView class]]);
  81   return static_cast<TabView*>([self view]);
  82 }
  83
  84 - (id)init {
  85   if ((self = [super init])) {
  86     // Icon.
  87     // Remember the icon's frame, so that if the icon is ever removed, a new
  88     // one can later replace it in the proper location.
  89     originalIconFrame_ = NSMakeRect(19, 5, 16, 16);
  90     iconView_.reset([[SpriteView alloc] initWithFrame:originalIconFrame_]);
  91     [iconView_ setAutoresizingMask:NSViewMaxXMargin | NSViewMinYMargin];
  92
  93     // When the icon is removed, the title expands to the left to fill the
  94     // space left by the icon.  When the close button is removed, the title
  95     // expands to the right to fill its space.  These are the amounts to expand
  96     // and contract the title frame under those conditions. We don't have to
  97     // explicilty save the offset between the title and the close button since
  98     // we can just get that value for the close button's frame.
  99     NSRect titleFrame = NSMakeRect(35, 6, 92, 14);
 100
 101     // Close button.
 102     closeButton_.reset([[HoverCloseButton alloc] initWithFrame:
 103         NSMakeRect(127, 4, 18, 18)]);
 104     [closeButton_ setAutoresizingMask:NSViewMinXMargin];
 105     [closeButton_ setTarget:self];
 106     [closeButton_ setAction:@selector(closeTab:)];
 107
 108     base::scoped_nsobject<TabView> view(
 109         [[TabView alloc] initWithFrame:NSMakeRect(0, 0, 160, 25)
 110                             controller:self
 111                            closeButton:closeButton_]);
 112     [view setAutoresizingMask:NSViewMaxXMargin | NSViewMinYMargin];
 113     [view addSubview:iconView_];
 114     [view addSubview:closeButton_];
 115     [view setTitleFrame:titleFrame];
 116     [super setView:view];
 117
 118     isIconShowing_ = YES;
 119     NSNotificationCenter* defaultCenter = [NSNotificationCenter defaultCenter];
 120     [defaultCenter addObserver:self
 121                       selector:@selector(themeChangedNotification:)
 122                           name:kBrowserThemeDidChangeNotification
 123                         object:nil];
 124
 125     [self internalSetSelected:selected_];
 126   }
 127   return self;
 128 }
 129
 130 - (void)dealloc {
 131   [mediaIndicatorView_ setAnimationDoneCallbackObject:nil withSelector:nil];
 132   [[NSNotificationCenter defaultCenter] removeObserver:self];
 133   [[self tabView] setController:nil];
 134   [super dealloc];
 135 }
 136
 137 // The internals of |-setSelected:| and |-setActive:| but doesn't set the
 138 // backing variables. This updates the drawing state and marks self as needing
 139 // a re-draw.
 140 - (void)internalSetSelected:(BOOL)selected {
 141   TabView* tabView = [self tabView];
 142   if ([self active]) {
 143     [tabView setState:NSOnState];
 144     [tabView cancelAlert];
 145   } else {
 146     [tabView setState:selected ? NSMixedState : NSOffState];
 147   }
 148   [self updateVisibility];
 149   [self updateTitleColor];
 150 }
 151
 152 // Called when Cocoa wants to display the context menu. Lazily instantiate
 153 // the menu based off of the cross-platform model. Re-create the menu and
 154 // model every time to get the correct labels and enabling.
 155 - (NSMenu*)menu {
 156   contextMenuDelegate_.reset(
 157       new TabControllerInternal::MenuDelegate(target_, self));
 158   contextMenuModel_.reset(
 159       [target_ contextMenuModelForController:self
 160                                 menuDelegate:contextMenuDelegate_.get()]);
 161   contextMenuController_.reset(
 162       [[MenuController alloc] initWithModel:contextMenuModel_.get()
 163                      useWithPopUpButtonCell:NO]);
 164   return [contextMenuController_ menu];
 165 }
 166
 167 - (void)closeTab:(id)sender {
 168   if ([[self target] respondsToSelector:@selector(closeTab:)]) {
 169     [[self target] performSelector:@selector(closeTab:)
 170                         withObject:[self view]];
 171   }
 172 }
 173
 174 - (void)selectTab:(id)sender {
 175   if ([[self tabView] isClosing])
 176     return;
 177   if ([[self target] respondsToSelector:[self action]]) {
 178     [[self target] performSelector:[self action]
 179                         withObject:[self view]];
 180   }
 181 }
 182
 183 - (void)setTitle:(NSString*)title {
 184   if ([[self title] isEqualToString:title])
 185     return;
 186
 187   TabView* tabView = [self tabView];
 188   [tabView setTitle:title];
 189
 190   if ([self mini] && ![self active]) {
 191     [tabView startAlert];
 192   }
 193   [super setTitle:title];
 194 }
 195
 196 - (void)setToolTip:(NSString*)toolTip {
 197   [[self view] setToolTip:toolTip];
 198 }
 199
 200 - (void)setActive:(BOOL)active {
 201   if (active != active_) {
 202     active_ = active;
 203     [self internalSetSelected:[self selected]];
 204   }
 205 }
 206
 207 - (BOOL)active {
 208   return active_;
 209 }
 210
 211 - (void)setSelected:(BOOL)selected {
 212   if (selected_ != selected) {
 213     selected_ = selected;
 214     [self internalSetSelected:[self selected]];
 215   }
 216 }
 217
 218 - (BOOL)selected {
 219   return selected_ || active_;
 220 }
 221
 222 - (SpriteView*)iconView {
 223   return iconView_;
 224 }
 225
 226 - (void)setIconView:(SpriteView*)iconView {
 227   [iconView_ removeFromSuperview];
 228   iconView_.reset([iconView retain]);
 229
 230   if (iconView_)
 231     [[self view] addSubview:iconView_];
 232 }
 233
 234 - (MediaIndicatorView*)mediaIndicatorView {
 235   return mediaIndicatorView_;
 236 }
 237
 238 - (void)setMediaIndicatorView:(MediaIndicatorView*)mediaIndicatorView {
 239   [mediaIndicatorView_ removeFromSuperview];
 240   mediaIndicatorView_.reset([mediaIndicatorView retain]);
 241   [self updateVisibility];
 242   if (mediaIndicatorView_) {
 243     [[self view] addSubview:mediaIndicatorView_];
 244     [mediaIndicatorView_
 245       setAnimationDoneCallbackObject:self
 246                         withSelector:@selector(updateVisibility)];
 247
 248   }
 249 }
 250
 251 - (HoverCloseButton*)closeButton {
 252   return closeButton_;
 253 }
 254
 255 - (NSString*)toolTip {
 256   return [[self tabView] toolTipText];
 257 }
 258
 259 // Return a rough approximation of the number of icons we could fit in the
 260 // tab. We never actually do this, but it's a helpful guide for determining
 261 // how much space we have available.
 262 - (int)iconCapacity {
 263   const CGFloat availableWidth = std::max<CGFloat>(
 264       0, NSMaxX([closeButton_ frame]) - NSMinX(originalIconFrame_));
 265   const CGFloat widthPerIcon = NSWidth(originalIconFrame_);
 266   const int kPaddingBetweenIcons = 2;
 267   if (availableWidth >= widthPerIcon &&
 268       availableWidth < (widthPerIcon + kPaddingBetweenIcons)) {
 269     return 1;
 270   }
 271   return availableWidth / (widthPerIcon + kPaddingBetweenIcons);
 272 }
 273
 274 - (BOOL)shouldShowIcon {
 275   return chrome::ShouldTabShowFavicon(
 276       [self iconCapacity], [self mini], [self active], iconView_ != nil,
 277       !mediaIndicatorView_ ? TAB_MEDIA_STATE_NONE :
 278           [mediaIndicatorView_ animatingMediaState]);
 279 }
 280
 281 - (BOOL)shouldShowMediaIndicator {
 282   if (!mediaIndicatorView_)
 283     return NO;
 284   return chrome::ShouldTabShowMediaIndicator(
 285       [self iconCapacity], [self mini], [self active], iconView_ != nil,
 286       [mediaIndicatorView_ animatingMediaState]);
 287 }
 288
 289 - (BOOL)shouldShowCloseButton {
 290   return chrome::ShouldTabShowCloseButton(
 291       [self iconCapacity], [self mini], [self active]);
 292 }
 293
 294 - (void)setIconImage:(NSImage*)image {
 295   [self setIconImage:image withToastAnimation:NO];
 296 }
 297
 298 - (void)setIconImage:(NSImage*)image withToastAnimation:(BOOL)animate {
 299   if (image == nil) {
 300     [self setIconView:nil];
 301   } else {
 302     if (iconView_.get() == nil) {
 303       base::scoped_nsobject<SpriteView> iconView([[SpriteView alloc] init]);
 304       [iconView setAutoresizingMask:NSViewMaxXMargin | NSViewMinYMargin];
 305       [self setIconView:iconView];
 306     }
 307
 308     [iconView_ setImage:image withToastAnimation:animate];
 309
 310     if ([self app] || [self mini]) {
 311       NSRect appIconFrame = [iconView_ frame];
 312       appIconFrame.origin = originalIconFrame_.origin;
 313
 314       const CGFloat tabWidth = [self app] ? [TabController appTabWidth]
 315                                           : [TabController miniTabWidth];
 316
 317       // Center the icon.
 318       appIconFrame.origin.x =
 319           std::floor((tabWidth - NSWidth(appIconFrame)) / 2.0);
 320       [iconView_ setFrame:appIconFrame];
 321     } else {
 322       [iconView_ setFrame:originalIconFrame_];
 323     }
 324   }
 325   // Ensure that the icon is suppressed if no icon is set or if the tab is too
 326   // narrow to display one.
 327   [self updateVisibility];
 328 }
 329
 330 - (void)updateVisibility {
 331   // iconView_ may have been replaced or it may be nil, so [iconView_ isHidden]
 332   // won't work.  Instead, the state of the icon is tracked separately in
 333   // isIconShowing_.
 334   BOOL newShowIcon = [self shouldShowIcon];
 335
 336   [iconView_ setHidden:!newShowIcon];
 337   isIconShowing_ = newShowIcon;
 338
 339   // If the tab is a mini-tab, hide the title.
 340   TabView* tabView = [self tabView];
 341   [tabView setTitleHidden:[self mini]];
 342
 343   BOOL newShowCloseButton = [self shouldShowCloseButton];
 344
 345   [closeButton_ setHidden:!newShowCloseButton];
 346
 347   BOOL newShowMediaIndicator = [self shouldShowMediaIndicator];
 348
 349   [mediaIndicatorView_ setHidden:!newShowMediaIndicator];
 350
 351   if (newShowMediaIndicator) {
 352     NSRect newFrame = [mediaIndicatorView_ frame];
 353     if ([self app] || [self mini]) {
 354       // Tab is pinned: Position the media indicator in the center.
 355       const CGFloat tabWidth = [self app] ?
 356           [TabController appTabWidth] : [TabController miniTabWidth];
 357       newFrame.origin.x = std::floor((tabWidth - NSWidth(newFrame)) / 2);
 358       newFrame.origin.y = NSMinY(originalIconFrame_) -
 359           std::floor((NSHeight(newFrame) - NSHeight(originalIconFrame_)) / 2);
 360     } else {
 361       // The Frame for the mediaIndicatorView_ depends on whether iconView_
 362       // and/or closeButton_ are visible, and where they have been positioned.
 363       const NSRect closeButtonFrame = [closeButton_ frame];
 364       newFrame.origin.x = NSMinX(closeButtonFrame);
 365       // Position to the left of the close button when it is showing.
 366       if (newShowCloseButton)
 367         newFrame.origin.x -= NSWidth(newFrame);
 368       // Media indicator is centered vertically, with respect to closeButton_.
 369       newFrame.origin.y = NSMinY(closeButtonFrame) -
 370           std::floor((NSHeight(newFrame) - NSHeight(closeButtonFrame)) / 2);
 371     }
 372     [mediaIndicatorView_ setFrame:newFrame];
 373   }
 374
 375   // Adjust the title view based on changes to the icon's and close button's
 376   // visibility.
 377   NSRect oldTitleFrame = [tabView titleFrame];
 378   NSRect newTitleFrame;
 379   newTitleFrame.size.height = oldTitleFrame.size.height;
 380   newTitleFrame.origin.y = oldTitleFrame.origin.y;
 381
 382   if (newShowIcon) {
 383     newTitleFrame.origin.x = NSMaxX([iconView_ frame]);
 384   } else {
 385     newTitleFrame.origin.x = originalIconFrame_.origin.x;
 386   }
 387
 388   if (newShowMediaIndicator) {
 389     newTitleFrame.size.width = NSMinX([mediaIndicatorView_ frame]) -
 390                                newTitleFrame.origin.x;
 391   } else if (newShowCloseButton) {
 392     newTitleFrame.size.width = NSMinX([closeButton_ frame]) -
 393                                newTitleFrame.origin.x;
 394   } else {
 395     newTitleFrame.size.width = NSMaxX([closeButton_ frame]) -
 396                                newTitleFrame.origin.x;
 397   }
 398
 399   [tabView setTitleFrame:newTitleFrame];
 400 }
 401
 402 - (void)updateTitleColor {
 403   NSColor* titleColor = nil;
 404   ui::ThemeProvider* theme = [[[self view] window] themeProvider];
 405   if (theme && ![self selected])
 406     titleColor = theme->GetNSColor(ThemeProperties::COLOR_BACKGROUND_TAB_TEXT);
 407   // Default to the selected text color unless told otherwise.
 408   if (theme && !titleColor)
 409     titleColor = theme->GetNSColor(ThemeProperties::COLOR_TAB_TEXT);
 410   [[self tabView] setTitleColor:titleColor ? titleColor : [NSColor textColor]];
 411 }
 412
 413 - (void)themeChangedNotification:(NSNotification*)notification {
 414   [self updateTitleColor];
 415 }
 416
 417 // Called by the tabs to determine whether we are in rapid (tab) closure mode.
 418 - (BOOL)inRapidClosureMode {
 419   if ([[self target] respondsToSelector:@selector(inRapidClosureMode)]) {
 420     return [[self target] performSelector:@selector(inRapidClosureMode)] ?
 421         YES : NO;
 422   }
 423   return NO;
 424 }
 425
 426 // The following methods are invoked from the TabView and are forwarded to the
 427 // TabStripDragController.
 428 - (BOOL)tabCanBeDragged:(TabController*)controller {
 429   return [[target_ dragController] tabCanBeDragged:controller];
 430 }
 431
 432 - (void)maybeStartDrag:(NSEvent*)event forTab:(TabController*)tab {
 433   [[target_ dragController] maybeStartDrag:event forTab:tab];
 434 }
 435
 436 @end