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