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