ui/base/cocoa/menu_controller.mm

   1 // Copyright 2013 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 "ui/base/cocoa/menu_controller.h"
   6
   7 #include "base/logging.h"
   8 #include "base/strings/sys_string_conversions.h"
   9 #include "ui/base/accelerators/accelerator.h"
  10 #include "ui/base/accelerators/platform_accelerator_cocoa.h"
  11 #include "ui/base/l10n/l10n_util_mac.h"
  12 #include "ui/base/models/simple_menu_model.h"
  13 #import "ui/events/event_utils.h"
  14 #include "ui/gfx/font_list.h"
  15 #include "ui/gfx/image/image.h"
  16 #include "ui/gfx/text_elider.h"
  17
  18 @interface MenuController (Private)
  19 - (void)addSeparatorToMenu:(NSMenu*)menu
  20                    atIndex:(int)index;
  21 @end
  22
  23 @implementation MenuController
  24
  25 @synthesize model = model_;
  26 @synthesize useWithPopUpButtonCell = useWithPopUpButtonCell_;
  27
  28 + (base::string16)elideMenuTitle:(const base::string16&)title
  29                          toWidth:(int)width {
  30   NSFont* nsfont = [NSFont menuBarFontOfSize:0];  // 0 means "default"
  31   return gfx::ElideText(title, gfx::FontList(gfx::Font(nsfont)), width,
  32                         gfx::ELIDE_TAIL);
  33 }
  34
  35 - (id)init {
  36   self = [super init];
  37   return self;
  38 }
  39
  40 - (id)initWithModel:(ui::MenuModel*)model
  41     useWithPopUpButtonCell:(BOOL)useWithCell {
  42   if ((self = [super init])) {
  43     model_ = model;
  44     useWithPopUpButtonCell_ = useWithCell;
  45     [self menu];
  46   }
  47   return self;
  48 }
  49
  50 - (void)dealloc {
  51   [menu_ setDelegate:nil];
  52
  53   // Close the menu if it is still open. This could happen if a tab gets closed
  54   // while its context menu is still open.
  55   [self cancel];
  56
  57   model_ = NULL;
  58   [super dealloc];
  59 }
  60
  61 - (void)cancel {
  62   if (isMenuOpen_) {
  63     [menu_ cancelTracking];
  64     model_->MenuClosed();
  65     isMenuOpen_ = NO;
  66   }
  67 }
  68
  69 // Creates a NSMenu from the given model. If the model has submenus, this can
  70 // be invoked recursively.
  71 - (NSMenu*)menuFromModel:(ui::MenuModel*)model {
  72   NSMenu* menu = [[[NSMenu alloc] initWithTitle:@""] autorelease];
  73
  74   const int count = model->GetItemCount();
  75   for (int index = 0; index < count; index++) {
  76     if (model->GetTypeAt(index) == ui::MenuModel::TYPE_SEPARATOR)
  77       [self addSeparatorToMenu:menu atIndex:index];
  78     else
  79       [self addItemToMenu:menu atIndex:index fromModel:model];
  80   }
  81
  82   return menu;
  83 }
  84
  85 - (int)maxWidthForMenuModel:(ui::MenuModel*)model
  86                  modelIndex:(int)modelIndex {
  87   return -1;
  88 }
  89
  90 // Adds a separator item at the given index. As the separator doesn't need
  91 // anything from the model, this method doesn't need the model index as the
  92 // other method below does.
  93 - (void)addSeparatorToMenu:(NSMenu*)menu
  94                    atIndex:(int)index {
  95   NSMenuItem* separator = [NSMenuItem separatorItem];
  96   [menu insertItem:separator atIndex:index];
  97 }
  98
  99 // Adds an item or a hierarchical menu to the item at the |index|,
 100 // associated with the entry in the model identified by |modelIndex|.
 101 - (void)addItemToMenu:(NSMenu*)menu
 102               atIndex:(NSInteger)index
 103             fromModel:(ui::MenuModel*)model {
 104   base::string16 label16 = model->GetLabelAt(index);
 105   int maxWidth = [self maxWidthForMenuModel:model modelIndex:index];
 106   if (maxWidth != -1)
 107     label16 = [MenuController elideMenuTitle:label16 toWidth:maxWidth];
 108
 109   NSString* label = l10n_util::FixUpWindowsStyleLabel(label16);
 110   base::scoped_nsobject<NSMenuItem> item(
 111       [[NSMenuItem alloc] initWithTitle:label
 112                                  action:@selector(itemSelected:)
 113                           keyEquivalent:@""]);
 114
 115   // If the menu item has an icon, set it.
 116   gfx::Image icon;
 117   if (model->GetIconAt(index, &icon) && !icon.IsEmpty())
 118     [item setImage:icon.ToNSImage()];
 119
 120   ui::MenuModel::ItemType type = model->GetTypeAt(index);
 121   if (type == ui::MenuModel::TYPE_SUBMENU) {
 122     // Recursively build a submenu from the sub-model at this index.
 123     [item setTarget:nil];
 124     [item setAction:nil];
 125     ui::MenuModel* submenuModel = model->GetSubmenuModelAt(index);
 126     NSMenu* submenu =
 127         [self menuFromModel:(ui::SimpleMenuModel*)submenuModel];
 128     [item setSubmenu:submenu];
 129   } else {
 130     // The MenuModel works on indexes so we can't just set the command id as the
 131     // tag like we do in other menus. Also set the represented object to be
 132     // the model so hierarchical menus check the correct index in the correct
 133     // model. Setting the target to |self| allows this class to participate
 134     // in validation of the menu items.
 135     [item setTag:index];
 136     [item setTarget:self];
 137     NSValue* modelObject = [NSValue valueWithPointer:model];
 138     [item setRepresentedObject:modelObject];  // Retains |modelObject|.
 139     ui::Accelerator accelerator;
 140     if (model->GetAcceleratorAt(index, &accelerator)) {
 141       const ui::PlatformAcceleratorCocoa* platformAccelerator =
 142           static_cast<const ui::PlatformAcceleratorCocoa*>(
 143               accelerator.platform_accelerator());
 144       if (platformAccelerator) {
 145         [item setKeyEquivalent:platformAccelerator->characters()];
 146         [item setKeyEquivalentModifierMask:
 147             platformAccelerator->modifier_mask()];
 148       }
 149     }
 150   }
 151   [menu insertItem:item atIndex:index];
 152 }
 153
 154 // Called before the menu is to be displayed to update the state (enabled,
 155 // radio, etc) of each item in the menu. Also will update the title if
 156 // the item is marked as "dynamic".
 157 - (BOOL)validateUserInterfaceItem:(id<NSValidatedUserInterfaceItem>)item {
 158   SEL action = [item action];
 159   if (action != @selector(itemSelected:))
 160     return NO;
 161
 162   NSInteger modelIndex = [item tag];
 163   ui::MenuModel* model =
 164       static_cast<ui::MenuModel*>(
 165           [[(id)item representedObject] pointerValue]);
 166   DCHECK(model);
 167   if (model) {
 168     BOOL checked = model->IsItemCheckedAt(modelIndex);
 169     DCHECK([(id)item isKindOfClass:[NSMenuItem class]]);
 170     [(id)item setState:(checked ? NSOnState : NSOffState)];
 171     [(id)item setHidden:(!model->IsVisibleAt(modelIndex))];
 172     if (model->IsItemDynamicAt(modelIndex)) {
 173       // Update the label and the icon.
 174       NSString* label =
 175           l10n_util::FixUpWindowsStyleLabel(model->GetLabelAt(modelIndex));
 176       [(id)item setTitle:label];
 177
 178       gfx::Image icon;
 179       model->GetIconAt(modelIndex, &icon);
 180       [(id)item setImage:icon.IsEmpty() ? nil : icon.ToNSImage()];
 181     }
 182     const gfx::FontList* font_list = model->GetLabelFontListAt(modelIndex);
 183     if (font_list) {
 184       NSDictionary *attributes =
 185           [NSDictionary dictionaryWithObject:font_list->GetPrimaryFont().
 186                                              GetNativeFont()
 187                                       forKey:NSFontAttributeName];
 188       base::scoped_nsobject<NSAttributedString> title(
 189           [[NSAttributedString alloc] initWithString:[(id)item title]
 190                                           attributes:attributes]);
 191       [(id)item setAttributedTitle:title.get()];
 192     }
 193     return model->IsEnabledAt(modelIndex);
 194   }
 195   return NO;
 196 }
 197
 198 // Called when the user chooses a particular menu item. |sender| is the menu
 199 // item chosen.
 200 - (void)itemSelected:(id)sender {
 201   NSInteger modelIndex = [sender tag];
 202   ui::MenuModel* model =
 203       static_cast<ui::MenuModel*>(
 204           [[sender representedObject] pointerValue]);
 205   DCHECK(model);
 206   if (model) {
 207     int event_flags = ui::EventFlagsFromNative([NSApp currentEvent]);
 208     model->ActivatedAt(modelIndex, event_flags);
 209   }
 210 }
 211
 212 - (NSMenu*)menu {
 213   if (!menu_ && model_) {
 214     menu_.reset([[self menuFromModel:model_] retain]);
 215     [menu_ setDelegate:self];
 216     // If this is to be used with a NSPopUpButtonCell, add an item at the 0th
 217     // position that's empty. Doing it after the menu has been constructed won't
 218     // complicate creation logic, and since the tags are model indexes, they
 219     // are unaffected by the extra item.
 220     if (useWithPopUpButtonCell_) {
 221       base::scoped_nsobject<NSMenuItem> blankItem(
 222           [[NSMenuItem alloc] initWithTitle:@"" action:nil keyEquivalent:@""]);
 223       [menu_ insertItem:blankItem atIndex:0];
 224     }
 225   }
 226   return menu_.get();
 227 }
 228
 229 - (BOOL)isMenuOpen {
 230   return isMenuOpen_;
 231 }
 232
 233 - (void)menuWillOpen:(NSMenu*)menu {
 234   isMenuOpen_ = YES;
 235   model_->MenuWillShow();
 236 }
 237
 238 - (void)menuDidClose:(NSMenu*)menu {
 239   if (isMenuOpen_) {
 240     model_->MenuClosed();
 241     isMenuOpen_ = NO;
 242   }
 243 }
 244
 245 @end