ui/views/widget/native_widget_mac.mm

   1 // Copyright 2014 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 "ui/views/widget/native_widget_mac.h"
   6
   7 #import <Cocoa/Cocoa.h>
   8
   9 #include "base/mac/foundation_util.h"
  10 #include "base/mac/scoped_nsobject.h"
  11 #include "base/strings/sys_string_conversions.h"
  12 #include "ui/gfx/font_list.h"
  13 #import "ui/gfx/mac/coordinate_conversion.h"
  14 #include "ui/native_theme/native_theme.h"
  15 #import "ui/views/cocoa/bridged_content_view.h"
  16 #import "ui/views/cocoa/bridged_native_widget.h"
  17 #import "ui/views/cocoa/views_nswindow_delegate.h"
  18 #include "ui/views/window/native_frame_view.h"
  19
  20 @interface NativeWidgetMacNSWindow : NSWindow
  21 - (ViewsNSWindowDelegate*)viewsNSWindowDelegate;
  22 @end
  23
  24 @implementation NativeWidgetMacNSWindow
  25
  26 - (ViewsNSWindowDelegate*)viewsNSWindowDelegate {
  27   return base::mac::ObjCCastStrict<ViewsNSWindowDelegate>([self delegate]);
  28 }
  29
  30 // Override canBecome{Key,Main}Window to always return YES, otherwise Windows
  31 // with a styleMask of NSBorderlessWindowMask default to NO.
  32 - (BOOL)canBecomeKeyWindow {
  33   return YES;
  34 }
  35
  36 - (BOOL)canBecomeMainWindow {
  37   return YES;
  38 }
  39
  40 // Override orderWindow to intercept visibility changes, since there is no way
  41 // to observe these changes via NSWindowDelegate.
  42 - (void)orderWindow:(NSWindowOrderingMode)orderingMode
  43          relativeTo:(NSInteger)otherWindowNumber {
  44   [[self viewsNSWindowDelegate] onWindowOrderWillChange:orderingMode];
  45   [super orderWindow:orderingMode relativeTo:otherWindowNumber];
  46   [[self viewsNSWindowDelegate] onWindowOrderChanged];
  47 }
  48
  49 @end
  50
  51 namespace views {
  52 namespace {
  53
  54 NSInteger StyleMaskForParams(const Widget::InitParams& params) {
  55   // TODO(tapted): Determine better masks when there are use cases for it.
  56   if (params.remove_standard_frame)
  57     return NSBorderlessWindowMask;
  58
  59   if (params.type == Widget::InitParams::TYPE_WINDOW) {
  60     return NSTitledWindowMask | NSClosableWindowMask |
  61            NSMiniaturizableWindowMask | NSResizableWindowMask;
  62   }
  63   return NSBorderlessWindowMask;
  64 }
  65
  66 NSRect ValidateContentRect(NSRect content_rect) {
  67   // A contentRect with zero width or height is a banned practice in Chrome, due
  68   // to unpredictable OSX treatment. For now, silently give a minimum dimension.
  69   // TODO(tapted): Add a DCHECK, or add emulation logic (e.g. to auto-hide).
  70   if (NSWidth(content_rect) == 0)
  71     content_rect.size.width = 1;
  72
  73   if (NSHeight(content_rect) == 0)
  74     content_rect.size.height = 1;
  75
  76   return content_rect;
  77 }
  78
  79 gfx::Size WindowSizeForClientAreaSize(NSWindow* window, const gfx::Size& size) {
  80   NSRect content_rect = NSMakeRect(0, 0, size.width(), size.height());
  81   NSRect frame_rect = [window frameRectForContentRect:content_rect];
  82   return gfx::Size(NSWidth(frame_rect), NSHeight(frame_rect));
  83 }
  84
  85 }  // namespace
  86
  87 ////////////////////////////////////////////////////////////////////////////////
  88 // NativeWidgetMac, public:
  89
  90 NativeWidgetMac::NativeWidgetMac(internal::NativeWidgetDelegate* delegate)
  91     : delegate_(delegate),
  92       bridge_(new BridgedNativeWidget(this)),
  93       ownership_(Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET) {
  94 }
  95
  96 NativeWidgetMac::~NativeWidgetMac() {
  97   if (ownership_ == Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET)
  98     delete delegate_;
  99   else
 100     CloseNow();
 101 }
 102
 103 void NativeWidgetMac::OnWindowWillClose() {
 104   delegate_->OnNativeWidgetDestroying();
 105   // Note: If closed via CloseNow(), |bridge_| will already be reset. If closed
 106   // by the user, or via Close() and a RunLoop, this will reset it.
 107   bridge_.reset();
 108   delegate_->OnNativeWidgetDestroyed();
 109   if (ownership_ == Widget::InitParams::NATIVE_WIDGET_OWNS_WIDGET)
 110     delete this;
 111 }
 112
 113 ////////////////////////////////////////////////////////////////////////////////
 114 // NativeWidgetMac, internal::NativeWidgetPrivate implementation:
 115
 116 void NativeWidgetMac::InitNativeWidget(const Widget::InitParams& params) {
 117   ownership_ = params.ownership;
 118
 119   NSInteger style_mask = StyleMaskForParams(params);
 120   NSRect content_rect = ValidateContentRect(
 121       [NSWindow contentRectForFrameRect:gfx::ScreenRectToNSRect(params.bounds)
 122                               styleMask:style_mask]);
 123
 124   base::scoped_nsobject<NSWindow> window([[NativeWidgetMacNSWindow alloc]
 125       initWithContentRect:content_rect
 126                 styleMask:style_mask
 127                   backing:NSBackingStoreBuffered
 128                     defer:YES]);
 129   [window setReleasedWhenClosed:NO];  // Owned by scoped_nsobject.
 130   bridge_->Init(window, params);
 131
 132   delegate_->OnNativeWidgetCreated(true);
 133
 134   bridge_->SetFocusManager(GetWidget()->GetFocusManager());
 135
 136   DCHECK(GetWidget()->GetRootView());
 137   bridge_->SetRootView(GetWidget()->GetRootView());
 138 }
 139
 140 NonClientFrameView* NativeWidgetMac::CreateNonClientFrameView() {
 141   return new NativeFrameView(GetWidget());
 142 }
 143
 144 bool NativeWidgetMac::ShouldUseNativeFrame() const {
 145   return true;
 146 }
 147
 148 bool NativeWidgetMac::ShouldWindowContentsBeTransparent() const {
 149   NOTIMPLEMENTED();
 150   return false;
 151 }
 152
 153 void NativeWidgetMac::FrameTypeChanged() {
 154   NOTIMPLEMENTED();
 155 }
 156
 157 Widget* NativeWidgetMac::GetWidget() {
 158   return delegate_->AsWidget();
 159 }
 160
 161 const Widget* NativeWidgetMac::GetWidget() const {
 162   return delegate_->AsWidget();
 163 }
 164
 165 gfx::NativeView NativeWidgetMac::GetNativeView() const {
 166   // Returns a BridgedContentView, unless there is no views::RootView set.
 167   return [GetNativeWindow() contentView];
 168 }
 169
 170 gfx::NativeWindow NativeWidgetMac::GetNativeWindow() const {
 171   return bridge_ ? bridge_->ns_window() : nil;
 172 }
 173
 174 Widget* NativeWidgetMac::GetTopLevelWidget() {
 175   NativeWidgetPrivate* native_widget = GetTopLevelNativeWidget(GetNativeView());
 176   return native_widget ? native_widget->GetWidget() : NULL;
 177 }
 178
 179 const ui::Compositor* NativeWidgetMac::GetCompositor() const {
 180   NOTIMPLEMENTED();
 181   return NULL;
 182 }
 183
 184 ui::Compositor* NativeWidgetMac::GetCompositor() {
 185   NOTIMPLEMENTED();
 186   return NULL;
 187 }
 188
 189 ui::Layer* NativeWidgetMac::GetLayer() {
 190   NOTIMPLEMENTED();
 191   return NULL;
 192 }
 193
 194 void NativeWidgetMac::ReorderNativeViews() {
 195   if (bridge_)
 196     bridge_->SetRootView(GetWidget()->GetRootView());
 197 }
 198
 199 void NativeWidgetMac::ViewRemoved(View* view) {
 200   NOTIMPLEMENTED();
 201 }
 202
 203 void NativeWidgetMac::SetNativeWindowProperty(const char* name, void* value) {
 204   NOTIMPLEMENTED();
 205 }
 206
 207 void* NativeWidgetMac::GetNativeWindowProperty(const char* name) const {
 208   NOTIMPLEMENTED();
 209   return NULL;
 210 }
 211
 212 TooltipManager* NativeWidgetMac::GetTooltipManager() const {
 213   NOTIMPLEMENTED();
 214   return NULL;
 215 }
 216
 217 void NativeWidgetMac::SetCapture() {
 218   NOTIMPLEMENTED();
 219 }
 220
 221 void NativeWidgetMac::ReleaseCapture() {
 222   NOTIMPLEMENTED();
 223 }
 224
 225 bool NativeWidgetMac::HasCapture() const {
 226   NOTIMPLEMENTED();
 227   return false;
 228 }
 229
 230 InputMethod* NativeWidgetMac::CreateInputMethod() {
 231   return bridge_ ? bridge_->CreateInputMethod() : NULL;
 232 }
 233
 234 internal::InputMethodDelegate* NativeWidgetMac::GetInputMethodDelegate() {
 235   return bridge_.get();
 236 }
 237
 238 ui::InputMethod* NativeWidgetMac::GetHostInputMethod() {
 239   return bridge_ ? bridge_->GetHostInputMethod() : NULL;
 240 }
 241
 242 void NativeWidgetMac::CenterWindow(const gfx::Size& size) {
 243   SetSize(WindowSizeForClientAreaSize(GetNativeWindow(), size));
 244   // Note that this is not the precise center of screen, but it is the standard
 245   // location for windows like dialogs to appear on screen for Mac.
 246   // TODO(tapted): If there is a parent window, center in that instead.
 247   [GetNativeWindow() center];
 248 }
 249
 250 void NativeWidgetMac::GetWindowPlacement(gfx::Rect* bounds,
 251                                          ui::WindowShowState* maximized) const {
 252   NOTIMPLEMENTED();
 253 }
 254
 255 bool NativeWidgetMac::SetWindowTitle(const base::string16& title) {
 256   NSWindow* window = GetNativeWindow();
 257   NSString* current_title = [window title];
 258   NSString* new_title = SysUTF16ToNSString(title);
 259   if ([current_title isEqualToString:new_title])
 260     return false;
 261
 262   [window setTitle:new_title];
 263   return true;
 264 }
 265
 266 void NativeWidgetMac::SetWindowIcons(const gfx::ImageSkia& window_icon,
 267                                      const gfx::ImageSkia& app_icon) {
 268   NOTIMPLEMENTED();
 269 }
 270
 271 void NativeWidgetMac::InitModalType(ui::ModalType modal_type) {
 272   NOTIMPLEMENTED();
 273 }
 274
 275 gfx::Rect NativeWidgetMac::GetWindowBoundsInScreen() const {
 276   return gfx::ScreenRectFromNSRect([GetNativeWindow() frame]);
 277 }
 278
 279 gfx::Rect NativeWidgetMac::GetClientAreaBoundsInScreen() const {
 280   NSWindow* window = GetNativeWindow();
 281   return gfx::ScreenRectFromNSRect(
 282       [window contentRectForFrameRect:[window frame]]);
 283 }
 284
 285 gfx::Rect NativeWidgetMac::GetRestoredBounds() const {
 286   return bridge_ ? bridge_->GetRestoredBounds() : gfx::Rect();
 287 }
 288
 289 void NativeWidgetMac::SetBounds(const gfx::Rect& bounds) {
 290   [GetNativeWindow() setFrame:gfx::ScreenRectToNSRect(bounds)
 291                       display:YES
 292                       animate:NO];
 293 }
 294
 295 void NativeWidgetMac::SetSize(const gfx::Size& size) {
 296   // Ensure the top-left corner stays in-place (rather than the bottom-left,
 297   // which -[NSWindow setContentSize:] would do).
 298   SetBounds(gfx::Rect(GetWindowBoundsInScreen().origin(), size));
 299 }
 300
 301 void NativeWidgetMac::StackAbove(gfx::NativeView native_view) {
 302   NOTIMPLEMENTED();
 303 }
 304
 305 void NativeWidgetMac::StackAtTop() {
 306   NOTIMPLEMENTED();
 307 }
 308
 309 void NativeWidgetMac::StackBelow(gfx::NativeView native_view) {
 310   NOTIMPLEMENTED();
 311 }
 312
 313 void NativeWidgetMac::SetShape(gfx::NativeRegion shape) {
 314   NOTIMPLEMENTED();
 315 }
 316
 317 void NativeWidgetMac::Close() {
 318   if (!bridge_)
 319     return;
 320
 321   // Clear the view early to suppress repaints.
 322   bridge_->SetRootView(NULL);
 323
 324   NSWindow* window = GetNativeWindow();
 325   // Calling performClose: will momentarily highlight the close button, but
 326   // AppKit will reject it if there is no close button.
 327   SEL close_selector = ([window styleMask] & NSClosableWindowMask)
 328                            ? @selector(performClose:)
 329                            : @selector(close);
 330   [window performSelector:close_selector withObject:nil afterDelay:0];
 331 }
 332
 333 void NativeWidgetMac::CloseNow() {
 334   // Reset |bridge_| to NULL before destroying it.
 335   scoped_ptr<BridgedNativeWidget> bridge(bridge_.Pass());
 336 }
 337
 338 void NativeWidgetMac::Show() {
 339   ShowWithWindowState(ui::SHOW_STATE_NORMAL);
 340 }
 341
 342 void NativeWidgetMac::Hide() {
 343   NOTIMPLEMENTED();
 344 }
 345
 346 void NativeWidgetMac::ShowMaximizedWithBounds(
 347     const gfx::Rect& restored_bounds) {
 348   NOTIMPLEMENTED();
 349 }
 350
 351 void NativeWidgetMac::ShowWithWindowState(ui::WindowShowState state) {
 352   switch (state) {
 353     case ui::SHOW_STATE_DEFAULT:
 354     case ui::SHOW_STATE_NORMAL:
 355     case ui::SHOW_STATE_INACTIVE:
 356       break;
 357     case ui::SHOW_STATE_MINIMIZED:
 358     case ui::SHOW_STATE_MAXIMIZED:
 359     case ui::SHOW_STATE_FULLSCREEN:
 360       NOTIMPLEMENTED();
 361       break;
 362     case ui::SHOW_STATE_END:
 363       NOTREACHED();
 364       break;
 365   }
 366   if (state == ui::SHOW_STATE_INACTIVE) {
 367     if (!IsVisible())
 368       [GetNativeWindow() orderBack:nil];
 369   } else {
 370     Activate();
 371   }
 372 }
 373
 374 bool NativeWidgetMac::IsVisible() const {
 375   return [GetNativeWindow() isVisible];
 376 }
 377
 378 void NativeWidgetMac::Activate() {
 379   [GetNativeWindow() makeKeyAndOrderFront:nil];
 380   [NSApp activateIgnoringOtherApps:YES];
 381 }
 382
 383 void NativeWidgetMac::Deactivate() {
 384   NOTIMPLEMENTED();
 385 }
 386
 387 bool NativeWidgetMac::IsActive() const {
 388   // To behave like ::GetActiveWindow on Windows, IsActive() must return the
 389   // "active" window attached to the calling application. NSWindow provides
 390   // -isKeyWindow and -isMainWindow, but these are system-wide and update
 391   // asynchronously. A window can not be main or key on Mac without the
 392   // application being active.
 393   // Here, define the active window as the frontmost visible window in the
 394   // application.
 395   // Note that this might not be the keyWindow, even when Chrome is active.
 396   // Also note that -[NSApplication orderedWindows] excludes panels and other
 397   // "unscriptable" windows, but includes invisible windows.
 398   if (!IsVisible())
 399     return false;
 400
 401   NSWindow* window = GetNativeWindow();
 402   for (NSWindow* other_window in [NSApp orderedWindows]) {
 403     if ([window isEqual:other_window])
 404       return true;
 405
 406     if ([other_window isVisible])
 407       return false;
 408   }
 409
 410   return false;
 411 }
 412
 413 void NativeWidgetMac::SetAlwaysOnTop(bool always_on_top) {
 414   NOTIMPLEMENTED();
 415 }
 416
 417 bool NativeWidgetMac::IsAlwaysOnTop() const {
 418   NOTIMPLEMENTED();
 419   return false;
 420 }
 421
 422 void NativeWidgetMac::SetVisibleOnAllWorkspaces(bool always_visible) {
 423   NOTIMPLEMENTED();
 424 }
 425
 426 void NativeWidgetMac::Maximize() {
 427   NOTIMPLEMENTED();  // See IsMaximized().
 428 }
 429
 430 void NativeWidgetMac::Minimize() {
 431   NOTIMPLEMENTED();
 432 }
 433
 434 bool NativeWidgetMac::IsMaximized() const {
 435   // The window frame isn't altered on Mac unless going fullscreen. The green
 436   // "+" button just makes the window bigger. So, always false.
 437   return false;
 438 }
 439
 440 bool NativeWidgetMac::IsMinimized() const {
 441   NOTIMPLEMENTED();
 442   return false;
 443 }
 444
 445 void NativeWidgetMac::Restore() {
 446   NOTIMPLEMENTED();
 447 }
 448
 449 void NativeWidgetMac::SetFullscreen(bool fullscreen) {
 450   if (!bridge_ || fullscreen == IsFullscreen())
 451     return;
 452
 453   bridge_->ToggleDesiredFullscreenState();
 454 }
 455
 456 bool NativeWidgetMac::IsFullscreen() const {
 457   return bridge_ && bridge_->target_fullscreen_state();
 458 }
 459
 460 void NativeWidgetMac::SetOpacity(unsigned char opacity) {
 461   NOTIMPLEMENTED();
 462 }
 463
 464 void NativeWidgetMac::SetUseDragFrame(bool use_drag_frame) {
 465   NOTIMPLEMENTED();
 466 }
 467
 468 void NativeWidgetMac::FlashFrame(bool flash_frame) {
 469   NOTIMPLEMENTED();
 470 }
 471
 472 void NativeWidgetMac::RunShellDrag(View* view,
 473                                    const ui::OSExchangeData& data,
 474                                    const gfx::Point& location,
 475                                    int operation,
 476                                    ui::DragDropTypes::DragEventSource source) {
 477   NOTIMPLEMENTED();
 478 }
 479
 480 void NativeWidgetMac::SchedulePaintInRect(const gfx::Rect& rect) {
 481   // TODO(tapted): This should use setNeedsDisplayInRect:, once the coordinate
 482   // system of |rect| has been converted.
 483   [GetNativeView() setNeedsDisplay:YES];
 484 }
 485
 486 void NativeWidgetMac::SetCursor(gfx::NativeCursor cursor) {
 487   NOTIMPLEMENTED();
 488 }
 489
 490 bool NativeWidgetMac::IsMouseEventsEnabled() const {
 491   NOTIMPLEMENTED();
 492   return true;
 493 }
 494
 495 void NativeWidgetMac::ClearNativeFocus() {
 496   NOTIMPLEMENTED();
 497 }
 498
 499 gfx::Rect NativeWidgetMac::GetWorkAreaBoundsInScreen() const {
 500   NOTIMPLEMENTED();
 501   return gfx::Rect();
 502 }
 503
 504 Widget::MoveLoopResult NativeWidgetMac::RunMoveLoop(
 505     const gfx::Vector2d& drag_offset,
 506     Widget::MoveLoopSource source,
 507     Widget::MoveLoopEscapeBehavior escape_behavior) {
 508   NOTIMPLEMENTED();
 509   return Widget::MOVE_LOOP_CANCELED;
 510 }
 511
 512 void NativeWidgetMac::EndMoveLoop() {
 513   NOTIMPLEMENTED();
 514 }
 515
 516 void NativeWidgetMac::SetVisibilityChangedAnimationsEnabled(bool value) {
 517   NOTIMPLEMENTED();
 518 }
 519
 520 ui::NativeTheme* NativeWidgetMac::GetNativeTheme() const {
 521   return ui::NativeTheme::instance();
 522 }
 523
 524 void NativeWidgetMac::OnRootViewLayout() {
 525   NOTIMPLEMENTED();
 526 }
 527
 528 bool NativeWidgetMac::IsTranslucentWindowOpacitySupported() const {
 529   return false;
 530 }
 531
 532 void NativeWidgetMac::OnSizeConstraintsChanged() {
 533   NOTIMPLEMENTED();
 534 }
 535
 536 void NativeWidgetMac::RepostNativeEvent(gfx::NativeEvent native_event) {
 537   NOTIMPLEMENTED();
 538 }
 539
 540 ////////////////////////////////////////////////////////////////////////////////
 541 // Widget, public:
 542
 543 bool Widget::ConvertRect(const Widget* source,
 544                          const Widget* target,
 545                          gfx::Rect* rect) {
 546   return false;
 547 }
 548
 549 namespace internal {
 550
 551 ////////////////////////////////////////////////////////////////////////////////
 552 // internal::NativeWidgetPrivate, public:
 553
 554 // static
 555 NativeWidgetPrivate* NativeWidgetPrivate::CreateNativeWidget(
 556     internal::NativeWidgetDelegate* delegate) {
 557   return new NativeWidgetMac(delegate);
 558 }
 559
 560 // static
 561 NativeWidgetPrivate* NativeWidgetPrivate::GetNativeWidgetForNativeView(
 562     gfx::NativeView native_view) {
 563   return GetNativeWidgetForNativeWindow([native_view window]);
 564 }
 565
 566 // static
 567 NativeWidgetPrivate* NativeWidgetPrivate::GetNativeWidgetForNativeWindow(
 568     gfx::NativeWindow native_window) {
 569   id<NSWindowDelegate> window_delegate = [native_window delegate];
 570   if ([window_delegate respondsToSelector:@selector(nativeWidgetMac)]) {
 571     ViewsNSWindowDelegate* delegate =
 572         base::mac::ObjCCastStrict<ViewsNSWindowDelegate>(window_delegate);
 573     return [delegate nativeWidgetMac];
 574   }
 575   return NULL;  // Not created by NativeWidgetMac.
 576 }
 577
 578 // static
 579 NativeWidgetPrivate* NativeWidgetPrivate::GetTopLevelNativeWidget(
 580     gfx::NativeView native_view) {
 581   NativeWidgetPrivate* native_widget =
 582       GetNativeWidgetForNativeView(native_view);
 583   if (!native_widget)
 584     return NULL;
 585
 586   for (NativeWidgetPrivate* parent;
 587        (parent = GetNativeWidgetForNativeWindow(
 588             [native_widget->GetNativeWindow() parentWindow]));
 589        native_widget = parent) {
 590   }
 591   return native_widget;
 592 }
 593
 594 // static
 595 void NativeWidgetPrivate::GetAllChildWidgets(gfx::NativeView native_view,
 596                                              Widget::Widgets* children) {
 597   NativeWidgetPrivate* native_widget =
 598       GetNativeWidgetForNativeView(native_view);
 599   if (!native_widget)
 600     return;
 601
 602   // Code expects widget for |native_view| to be added to |children|.
 603   if (native_widget->GetWidget())
 604     children->insert(native_widget->GetWidget());
 605
 606   for (NSWindow* child_window : [native_widget->GetNativeWindow() childWindows])
 607     GetAllChildWidgets([child_window contentView], children);
 608 }
 609
 610 // static
 611 void NativeWidgetPrivate::GetAllOwnedWidgets(gfx::NativeView native_view,
 612                                              Widget::Widgets* owned) {
 613   NOTIMPLEMENTED();
 614 }
 615
 616 // static
 617 void NativeWidgetPrivate::ReparentNativeView(gfx::NativeView native_view,
 618                                              gfx::NativeView new_parent) {
 619   NOTIMPLEMENTED();
 620 }
 621
 622 // static
 623 bool NativeWidgetPrivate::IsMouseButtonDown() {
 624   return [NSEvent pressedMouseButtons] != 0;
 625 }
 626
 627 // static
 628 gfx::FontList NativeWidgetPrivate::GetWindowTitleFontList() {
 629   NOTIMPLEMENTED();
 630   return gfx::FontList();
 631 }
 632
 633 }  // namespace internal
 634 }  // namespace views