content/shell/browser/shell_mac.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 #include "content/shell/browser/shell.h"
   6
   7 #include <algorithm>
   8
   9 #include "base/logging.h"
  10 #import "base/mac/scoped_nsobject.h"
  11 #include "base/mac/sdk_forward_declarations.h"
  12 #include "base/strings/string_piece.h"
  13 #include "base/strings/sys_string_conversions.h"
  14 #include "content/public/browser/native_web_keyboard_event.h"
  15 #include "content/public/browser/web_contents.h"
  16 #include "content/shell/app/resource.h"
  17 #import "ui/base/cocoa/underlay_opengl_hosting_window.h"
  18 #include "url/gurl.h"
  19
  20 // Receives notification that the window is closing so that it can start the
  21 // tear-down process. Is responsible for deleting itself when done.
  22 @interface ContentShellWindowDelegate : NSObject<NSWindowDelegate> {
  23  @private
  24   content::Shell* shell_;
  25 }
  26 - (id)initWithShell:(content::Shell*)shell;
  27 @end
  28
  29 @implementation ContentShellWindowDelegate
  30
  31 - (id)initWithShell:(content::Shell*)shell {
  32   if ((self = [super init])) {
  33     shell_ = shell;
  34   }
  35   return self;
  36 }
  37
  38 // Called when the window is about to close. Perform the self-destruction
  39 // sequence by getting rid of the shell and removing it and the window from
  40 // the various global lists. By returning YES, we allow the window to be
  41 // removed from the screen.
  42 - (BOOL)windowShouldClose:(id)window {
  43   [window autorelease];
  44   delete shell_;
  45   [self release];
  46
  47   return YES;
  48 }
  49
  50 - (void)performAction:(id)sender {
  51   shell_->ActionPerformed([sender tag]);
  52 }
  53
  54 - (void)takeURLStringValueFrom:(id)sender {
  55   shell_->URLEntered(base::SysNSStringToUTF8([sender stringValue]));
  56 }
  57
  58 @end
  59
  60 @interface CrShellWindow : UnderlayOpenGLHostingWindow {
  61  @private
  62   content::Shell* shell_;
  63 }
  64 - (void)setShell:(content::Shell*)shell;
  65 - (void)showDevTools:(id)sender;
  66 @end
  67
  68 @implementation CrShellWindow
  69
  70 - (void)setShell:(content::Shell*)shell {
  71   shell_ = shell;
  72 }
  73
  74 - (void)showDevTools:(id)sender {
  75   shell_->ShowDevTools();
  76 }
  77
  78 @end
  79
  80 namespace {
  81
  82 NSString* kWindowTitle = @"Content Shell";
  83
  84 // Layout constants (in view coordinates)
  85 const CGFloat kButtonWidth = 72;
  86 const CGFloat kURLBarHeight = 24;
  87
  88 // The minimum size of the window's content (in view coordinates)
  89 const CGFloat kMinimumWindowWidth = 400;
  90 const CGFloat kMinimumWindowHeight = 300;
  91
  92 void MakeShellButton(NSRect* rect,
  93                      NSString* title,
  94                      NSView* parent,
  95                      int control,
  96                      NSView* target,
  97                      NSString* key,
  98                      NSUInteger modifier) {
  99   base::scoped_nsobject<NSButton> button(
 100       [[NSButton alloc] initWithFrame:*rect]);
 101   [button setTitle:title];
 102   [button setBezelStyle:NSSmallSquareBezelStyle];
 103   [button setAutoresizingMask:(NSViewMaxXMargin | NSViewMinYMargin)];
 104   [button setTarget:target];
 105   [button setAction:@selector(performAction:)];
 106   [button setTag:control];
 107   [button setKeyEquivalent:key];
 108   [button setKeyEquivalentModifierMask:modifier];
 109   [parent addSubview:button];
 110   rect->origin.x += kButtonWidth;
 111 }
 112
 113 }  // namespace
 114
 115 namespace content {
 116
 117 void Shell::PlatformInitialize(const gfx::Size& default_window_size) {
 118 }
 119
 120 void Shell::PlatformExit() {
 121 }
 122
 123 void Shell::PlatformCleanUp() {
 124 }
 125
 126 void Shell::PlatformEnableUIControl(UIControl control, bool is_enabled) {
 127   if (headless_)
 128     return;
 129
 130   int id;
 131   switch (control) {
 132     case BACK_BUTTON:
 133       id = IDC_NAV_BACK;
 134       break;
 135     case FORWARD_BUTTON:
 136       id = IDC_NAV_FORWARD;
 137       break;
 138     case STOP_BUTTON:
 139       id = IDC_NAV_STOP;
 140       break;
 141     default:
 142       NOTREACHED() << "Unknown UI control";
 143       return;
 144   }
 145   [[[window_ contentView] viewWithTag:id] setEnabled:is_enabled];
 146 }
 147
 148 void Shell::PlatformSetAddressBarURL(const GURL& url) {
 149   if (headless_)
 150     return;
 151
 152   NSString* url_string = base::SysUTF8ToNSString(url.spec());
 153   [url_edit_view_ setStringValue:url_string];
 154 }
 155
 156 void Shell::PlatformSetIsLoading(bool loading) {
 157 }
 158
 159 void Shell::PlatformCreateWindow(int width, int height) {
 160   if (headless_) {
 161     content_size_ = gfx::Size(width, height);
 162     return;
 163   }
 164
 165   NSRect initial_window_bounds =
 166       NSMakeRect(0, 0, width, height + kURLBarHeight);
 167   NSRect content_rect = initial_window_bounds;
 168   NSUInteger style_mask = NSTitledWindowMask |
 169                           NSClosableWindowMask |
 170                           NSMiniaturizableWindowMask |
 171                           NSResizableWindowMask;
 172   CrShellWindow* window =
 173       [[CrShellWindow alloc] initWithContentRect:content_rect
 174                                        styleMask:style_mask
 175                                          backing:NSBackingStoreBuffered
 176                                            defer:NO];
 177   window_ = window;
 178   [window setShell:this];
 179   [window_ setTitle:kWindowTitle];
 180   NSView* content = [window_ contentView];
 181
 182   // If the window is allowed to get too small, it will wreck the view bindings.
 183   NSSize min_size = NSMakeSize(kMinimumWindowWidth, kMinimumWindowHeight);
 184   min_size = [content convertSize:min_size toView:nil];
 185   // Note that this takes window coordinates.
 186   [window_ setContentMinSize:min_size];
 187
 188   // Set the shell window to participate in Lion Fullscreen mode. Set
 189   // Setting this flag has no effect on Snow Leopard or earlier.
 190   NSUInteger collectionBehavior = [window_ collectionBehavior];
 191   collectionBehavior |= NSWindowCollectionBehaviorFullScreenPrimary;
 192   [window_ setCollectionBehavior:collectionBehavior];
 193
 194   // Rely on the window delegate to clean us up rather than immediately
 195   // releasing when the window gets closed. We use the delegate to do
 196   // everything from the autorelease pool so the shell isn't on the stack
 197   // during cleanup (ie, a window close from javascript).
 198   [window_ setReleasedWhenClosed:NO];
 199
 200   // Create a window delegate to watch for when it's asked to go away. It will
 201   // clean itself up so we don't need to hold a reference.
 202   ContentShellWindowDelegate* delegate =
 203       [[ContentShellWindowDelegate alloc] initWithShell:this];
 204   [window_ setDelegate:delegate];
 205
 206   NSRect button_frame =
 207       NSMakeRect(0, NSMaxY(initial_window_bounds) - kURLBarHeight,
 208                  kButtonWidth, kURLBarHeight);
 209
 210   MakeShellButton(&button_frame, @"Back", content, IDC_NAV_BACK,
 211                   (NSView*)delegate, @"[", NSCommandKeyMask);
 212   MakeShellButton(&button_frame, @"Forward", content, IDC_NAV_FORWARD,
 213                   (NSView*)delegate, @"]", NSCommandKeyMask);
 214   MakeShellButton(&button_frame, @"Reload", content, IDC_NAV_RELOAD,
 215                   (NSView*)delegate, @"r", NSCommandKeyMask);
 216   MakeShellButton(&button_frame, @"Stop", content, IDC_NAV_STOP,
 217                   (NSView*)delegate, @".", NSCommandKeyMask);
 218
 219   button_frame.size.width =
 220       NSWidth(initial_window_bounds) - NSMinX(button_frame);
 221   base::scoped_nsobject<NSTextField> url_edit_view(
 222       [[NSTextField alloc] initWithFrame:button_frame]);
 223   [content addSubview:url_edit_view];
 224   [url_edit_view setAutoresizingMask:(NSViewWidthSizable | NSViewMinYMargin)];
 225   [url_edit_view setTarget:delegate];
 226   [url_edit_view setAction:@selector(takeURLStringValueFrom:)];
 227   [[url_edit_view cell] setWraps:NO];
 228   [[url_edit_view cell] setScrollable:YES];
 229   url_edit_view_ = url_edit_view.get();
 230
 231   // show the window
 232   [window_ makeKeyAndOrderFront:nil];
 233 }
 234
 235 void Shell::PlatformSetContents() {
 236   NSView* web_view = web_contents_->GetNativeView();
 237   [web_view setAutoresizingMask:(NSViewWidthSizable | NSViewHeightSizable)];
 238
 239   if (headless_) {
 240     SizeTo(content_size_);
 241     return;
 242   }
 243
 244   NSView* content = [window_ contentView];
 245   [content addSubview:web_view];
 246
 247   NSRect frame = [content bounds];
 248   frame.size.height -= kURLBarHeight;
 249   [web_view setFrame:frame];
 250   [web_view setNeedsDisplay:YES];
 251 }
 252
 253 void Shell::SizeTo(const gfx::Size& content_size) {
 254   if (!headless_) {
 255     NSRect frame = NSMakeRect(
 256         0, 0, content_size.width(), content_size.height() + kURLBarHeight);
 257     [window().contentView setFrame:frame];
 258     return;
 259   }
 260   NSView* web_view = web_contents_->GetNativeView();
 261   NSRect frame = NSMakeRect(0, 0, content_size.width(), content_size.height());
 262   [web_view setFrame:frame];
 263 }
 264
 265 void Shell::PlatformResizeSubViews() {
 266   // Not needed; subviews are bound.
 267 }
 268
 269 void Shell::PlatformSetTitle(const base::string16& title) {
 270   if (headless_)
 271     return;
 272
 273   NSString* title_string = base::SysUTF16ToNSString(title);
 274   [window_ setTitle:title_string];
 275 }
 276
 277 bool Shell::PlatformHandleContextMenu(
 278     const content::ContextMenuParams& params) {
 279   return false;
 280 }
 281
 282 #if defined(TOOLKIT_VIEWS)
 283 void Shell::PlatformWebContentsFocused(WebContents* contents) {
 284   if (headless_)
 285     return;
 286
 287   NOTIMPLEMENTED();
 288   return;
 289 }
 290 #endif
 291
 292 void Shell::Close() {
 293   if (headless_)
 294     delete this;
 295   else
 296     [window_ performClose:nil];
 297 }
 298
 299 void Shell::ActionPerformed(int control) {
 300   switch (control) {
 301     case IDC_NAV_BACK:
 302       GoBackOrForward(-1);
 303       break;
 304     case IDC_NAV_FORWARD:
 305       GoBackOrForward(1);
 306       break;
 307     case IDC_NAV_RELOAD:
 308       Reload();
 309       break;
 310     case IDC_NAV_STOP:
 311       Stop();
 312       break;
 313   }
 314 }
 315
 316 void Shell::URLEntered(std::string url_string) {
 317   if (!url_string.empty()) {
 318     GURL url(url_string);
 319     if (!url.has_scheme())
 320       url = GURL("http://" + url_string);
 321     LoadURL(url);
 322   }
 323 }
 324
 325 void Shell::HandleKeyboardEvent(WebContents* source,
 326                                 const NativeWebKeyboardEvent& event) {
 327   if (event.skip_in_browser)
 328     return;
 329
 330   // The event handling to get this strictly right is a tangle; cheat here a bit
 331   // by just letting the menus have a chance at it.
 332   if ([event.os_event type] == NSKeyDown) {
 333     if (([event.os_event modifierFlags] & NSCommandKeyMask) &&
 334         [[event.os_event characters] isEqual:@"l"]) {
 335       [window_ makeFirstResponder:url_edit_view_];
 336       return;
 337     }
 338
 339     [[NSApp mainMenu] performKeyEquivalent:event.os_event];
 340   }
 341 }
 342
 343 }  // namespace content