STASH: Epic Experimental patch for toolkit-views App List on Mac

ui/views/widget/native_widget_mac.mm

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "ui/views/widget/native_widget_mac.h"
 
 #import <Cocoa/Cocoa.h>
 
 #include "base/mac/foundation_util.h"
+#import "base/mac/sdk_forward_declarations.h"
 #include "base/mac/scoped_nsobject.h"
 #include "base/strings/sys_string_conversions.h"
 #include "ui/gfx/font_list.h"
 #import "ui/gfx/mac/coordinate_conversion.h"
+#include "ui/gfx/screen.h"
 #include "ui/native_theme/native_theme.h"
 #import "ui/views/cocoa/bridged_content_view.h"
 #import "ui/views/cocoa/bridged_native_widget.h"
 #import "ui/views/cocoa/views_nswindow_delegate.h"
 #include "ui/views/window/native_frame_view.h"
 
 @interface NativeWidgetMacNSWindow : NSWindow
 - (ViewsNSWindowDelegate*)viewsNSWindowDelegate;
 @end
 
 @implementation NativeWidgetMacNSWindow
 
 - (ViewsNSWindowDelegate*)viewsNSWindowDelegate {
   return base::mac::ObjCCastStrict<ViewsNSWindowDelegate>([self delegate]);
 }
 
 // Override canBecome{Key,Main}Window to always return YES, otherwise Windows
 // with a styleMask of NSBorderlessWindowMask default to NO.
 - (BOOL)canBecomeKeyWindow {
   return YES;
 }
 
+// Also override canBecomeMainWindow, but ensure that transient child windows
+// do not achieve main status, even if key. Main status should stay with the
+// parent window.
 - (BOOL)canBecomeMainWindow {
-  return YES;
+  return ![[self viewsNSWindowDelegate] isTransientChild];
 }
 
 // Override orderWindow to intercept visibility changes, since there is no way
 // to observe these changes via NSWindowDelegate.
 - (void)orderWindow:(NSWindowOrderingMode)orderingMode
          relativeTo:(NSInteger)otherWindowNumber {
   [[self viewsNSWindowDelegate] onWindowOrderWillChange:orderingMode];
   [super orderWindow:orderingMode relativeTo:otherWindowNumber];
-  [[self viewsNSWindowDelegate] onWindowOrderChanged];
+  [[self viewsNSWindowDelegate] onWindowOrderChanged:nil];
 }
 
 @end
 
 namespace views {
 namespace {
 
 NSInteger StyleMaskForParams(const Widget::InitParams& params) {
   // TODO(tapted): Determine better masks when there are use cases for it.
   if (params.remove_standard_frame)
@@ skipping 13 matching lines @@
   if (NSWidth(content_rect) == 0)
     content_rect.size.width = 1;
 
   if (NSHeight(content_rect) == 0)
     content_rect.size.height = 1;
 
   return content_rect;
 }
 
 gfx::Size WindowSizeForClientAreaSize(NSWindow* window, const gfx::Size& size) {
-  NSRect content_rect = NSMakeRect(0, 0, size.width(), size.height());
+  DCHECK(window);
+  NSRect content_rect =
+      ValidateContentRect(NSMakeRect(0, 0, size.width(), size.height()));
   NSRect frame_rect = [window frameRectForContentRect:content_rect];
   return gfx::Size(NSWidth(frame_rect), NSHeight(frame_rect));
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // NativeWidgetMac, public:
 
 NativeWidgetMac::NativeWidgetMac(internal::NativeWidgetDelegate* delegate)
@@ skipping 48 matching lines @@
 
 NonClientFrameView* NativeWidgetMac::CreateNonClientFrameView() {
   return new NativeFrameView(GetWidget());
 }
 
 bool NativeWidgetMac::ShouldUseNativeFrame() const {
   return true;
 }
 
 bool NativeWidgetMac::ShouldWindowContentsBeTransparent() const {
-  NOTIMPLEMENTED();
-  return false;
+  return true;
 }
 
 void NativeWidgetMac::FrameTypeChanged() {
   NOTIMPLEMENTED();
 }
 
 Widget* NativeWidgetMac::GetWidget() {
   return delegate_->AsWidget();
 }
 
 const Widget* NativeWidgetMac::GetWidget() const {
   return delegate_->AsWidget();
 }
 
 gfx::NativeView NativeWidgetMac::GetNativeView() const {
   // Returns a BridgedContentView, unless there is no views::RootView set.
   return [GetNativeWindow() contentView];
 }
 
 gfx::NativeWindow NativeWidgetMac::GetNativeWindow() const {
   return bridge_ ? bridge_->ns_window() : nil;
 }
 
 Widget* NativeWidgetMac::GetTopLevelWidget() {
   NativeWidgetPrivate* native_widget = GetTopLevelNativeWidget(GetNativeView());
   return native_widget ? native_widget->GetWidget() : NULL;
 }
 
 const ui::Compositor* NativeWidgetMac::GetCompositor() const {
-  NOTIMPLEMENTED();
-  return NULL;
+  return bridge_->layer() ? bridge_->layer()->GetCompositor() : NULL;
 }
 
 ui::Compositor* NativeWidgetMac::GetCompositor() {
-  NOTIMPLEMENTED();
-  return NULL;
+  return bridge_->layer() ? bridge_->layer()->GetCompositor() : NULL;
 }
 
 ui::Layer* NativeWidgetMac::GetLayer() {
-  NOTIMPLEMENTED();
-  return NULL;
+  return bridge_->GetOrCreateLayer();
 }
 
 void NativeWidgetMac::ReorderNativeViews() {
   if (bridge_)
     bridge_->SetRootView(GetWidget()->GetRootView());
 }
 
 void NativeWidgetMac::ViewRemoved(View* view) {
   NOTIMPLEMENTED();
 }
 
 void NativeWidgetMac::SetNativeWindowProperty(const char* name, void* value) {
   NOTIMPLEMENTED();
 }
 
 void* NativeWidgetMac::GetNativeWindowProperty(const char* name) const {
   NOTIMPLEMENTED();
   return NULL;
 }
 
 TooltipManager* NativeWidgetMac::GetTooltipManager() const {
   NOTIMPLEMENTED();
   return NULL;
 }
 
 void NativeWidgetMac::SetCapture() {
-  NOTIMPLEMENTED();
+  // Basic mouse capture to simulate ::SetCapture() from Windows. Capture on OSX
+  // is automatic for mouse drag events. This allows mouse move events to also
+  // be sent to responders, but only when the mouse is over the window. To get
+  // move events outside the window, Mac will need an event tap.
+  [GetNativeWindow() setAcceptsMouseMovedEvents:YES];
+  //[GetNativeWindow() makeKeyWindow];
 }
 
 void NativeWidgetMac::ReleaseCapture() {
-  NOTIMPLEMENTED();
+  [GetNativeWindow() setAcceptsMouseMovedEvents:NO];
 }
 
 bool NativeWidgetMac::HasCapture() const {
-  NOTIMPLEMENTED();
-  return false;
+  return [GetNativeWindow() acceptsMouseMovedEvents];
 }
 
 InputMethod* NativeWidgetMac::CreateInputMethod() {
   return bridge_ ? bridge_->CreateInputMethod() : NULL;
 }
 
 internal::InputMethodDelegate* NativeWidgetMac::GetInputMethodDelegate() {
   return bridge_.get();
 }
 
 ui::InputMethod* NativeWidgetMac::GetHostInputMethod() {
   return bridge_ ? bridge_->GetHostInputMethod() : NULL;
 }
 
 void NativeWidgetMac::CenterWindow(const gfx::Size& size) {
   SetSize(WindowSizeForClientAreaSize(GetNativeWindow(), size));
   // Note that this is not the precise center of screen, but it is the standard
   // location for windows like dialogs to appear on screen for Mac.
   // TODO(tapted): If there is a parent window, center in that instead.
   [GetNativeWindow() center];
 }
 
-void NativeWidgetMac::GetWindowPlacement(gfx::Rect* bounds,
-                                         ui::WindowShowState* maximized) const {
-  NOTIMPLEMENTED();
+void NativeWidgetMac::GetWindowPlacement(
+    gfx::Rect* bounds,
+    ui::WindowShowState* show_state) const {
+  *bounds = GetRestoredBounds();
+  if (IsMinimized()) {
+    *show_state = ui::SHOW_STATE_MINIMIZED;
+    return;
+  }
+
+  if (IsFullscreen()) {
+    *show_state = ui::SHOW_STATE_FULLSCREEN;
+    return;
+  }
+
+  *show_state = ui::SHOW_STATE_DEFAULT;
 }
 
 bool NativeWidgetMac::SetWindowTitle(const base::string16& title) {
   NSWindow* window = GetNativeWindow();
   NSString* current_title = [window title];
   NSString* new_title = SysUTF16ToNSString(title);
   if ([current_title isEqualToString:new_title])
     return false;
 
   [window setTitle:new_title];
@@ skipping 17 matching lines @@
   NSWindow* window = GetNativeWindow();
   return gfx::ScreenRectFromNSRect(
       [window contentRectForFrameRect:[window frame]]);
 }
 
 gfx::Rect NativeWidgetMac::GetRestoredBounds() const {
   return bridge_ ? bridge_->GetRestoredBounds() : gfx::Rect();
 }
 
 void NativeWidgetMac::SetBounds(const gfx::Rect& bounds) {
+#if 1
   [GetNativeWindow() setFrame:gfx::ScreenRectToNSRect(bounds)
                       display:YES
                       animate:NO];
+  if (!IsVisible()) {
+    // If not visible, notifications do not come from Cocoa, so send our own.
+    //NSSize new_size = [GetNativeWindow() frame].size;
+    //GetWidget()->OnNativeWidgetSizeChanged(
+    //    gfx::Size(new_size.width, new_size.height));
+  }
+#else
+  if (bridge_)
+    bridge_->SetBounds(bounds);
+#endif
 }
 
 void NativeWidgetMac::SetSize(const gfx::Size& size) {
   // Ensure the top-left corner stays in-place (rather than the bottom-left,
   // which -[NSWindow setContentSize:] would do).
   SetBounds(gfx::Rect(GetWindowBoundsInScreen().origin(), size));
 }
 
 void NativeWidgetMac::StackAbove(gfx::NativeView native_view) {
   NOTIMPLEMENTED();
@@ skipping 30 matching lines @@
 void NativeWidgetMac::CloseNow() {
   // Reset |bridge_| to NULL before destroying it.
   scoped_ptr<BridgedNativeWidget> bridge(bridge_.Pass());
 }
 
 void NativeWidgetMac::Show() {
   ShowWithWindowState(ui::SHOW_STATE_NORMAL);
 }
 
 void NativeWidgetMac::Hide() {
-  NOTIMPLEMENTED();
+  [GetNativeWindow() orderOut:nil];
 }
 
 void NativeWidgetMac::ShowMaximizedWithBounds(
     const gfx::Rect& restored_bounds) {
   NOTIMPLEMENTED();
 }
 
 void NativeWidgetMac::ShowWithWindowState(ui::WindowShowState state) {
   switch (state) {
     case ui::SHOW_STATE_DEFAULT:
@@ skipping 67 matching lines @@
 
 void NativeWidgetMac::SetVisibleOnAllWorkspaces(bool always_visible) {
   NOTIMPLEMENTED();
 }
 
 void NativeWidgetMac::Maximize() {
   NOTIMPLEMENTED();  // See IsMaximized().
 }
 
 void NativeWidgetMac::Minimize() {
-  NOTIMPLEMENTED();
+  NSWindow* window = GetNativeWindow();
+  // Calling performMiniaturize: will momentarily highlight the button, but
+  // AppKit will reject it if there is no miniaturize button.
+  if ([window styleMask] & NSMiniaturizableWindowMask)
+    [window performMiniaturize:nil];
+  else
+    [window miniaturize:nil];
 }
 
 bool NativeWidgetMac::IsMaximized() const {
   // The window frame isn't altered on Mac unless going fullscreen. The green
   // "+" button just makes the window bigger. So, always false.
   return false;
 }
 
 bool NativeWidgetMac::IsMinimized() const {
-  NOTIMPLEMENTED();
-  return false;
+  return [GetNativeWindow() isMiniaturized];
 }
 
 void NativeWidgetMac::Restore() {
-  NOTIMPLEMENTED();
+  [GetNativeWindow() deminiaturize:nil];
 }
 
 void NativeWidgetMac::SetFullscreen(bool fullscreen) {
   if (!bridge_ || fullscreen == IsFullscreen())
     return;
 
   bridge_->ToggleDesiredFullscreenState();
 }
 
 bool NativeWidgetMac::IsFullscreen() const {
@@ skipping 17 matching lines @@
                                    const gfx::Point& location,
                                    int operation,
                                    ui::DragDropTypes::DragEventSource source) {
   NOTIMPLEMENTED();
 }
 
 void NativeWidgetMac::SchedulePaintInRect(const gfx::Rect& rect) {
   // TODO(tapted): This should use setNeedsDisplayInRect:, once the coordinate
   // system of |rect| has been converted.
   [GetNativeView() setNeedsDisplay:YES];
+  if (bridge_ && bridge_->layer()) {
+    bridge_->layer()->SchedulePaint(rect);
+  }
 }
 
 void NativeWidgetMac::SetCursor(gfx::NativeCursor cursor) {
   NOTIMPLEMENTED();
 }
 
 bool NativeWidgetMac::IsMouseEventsEnabled() const {
   NOTIMPLEMENTED();
   return true;
 }
 
 void NativeWidgetMac::ClearNativeFocus() {
   NOTIMPLEMENTED();
 }
 
 gfx::Rect NativeWidgetMac::GetWorkAreaBoundsInScreen() const {
-  NOTIMPLEMENTED();
-  return gfx::Rect();
+  NSView* view = GetNativeView();
+  if (!view)
+    return gfx::Rect();
+  return gfx::Screen::GetScreenFor(view)
+      ->GetDisplayNearestWindow(view)
+      .work_area();
 }
 
 Widget::MoveLoopResult NativeWidgetMac::RunMoveLoop(
     const gfx::Vector2d& drag_offset,
     Widget::MoveLoopSource source,
     Widget::MoveLoopEscapeBehavior escape_behavior) {
   NOTIMPLEMENTED();
   return Widget::MOVE_LOOP_CANCELED;
 }
 
@@ skipping 113 matching lines @@
 }
 
 // static
 gfx::FontList NativeWidgetPrivate::GetWindowTitleFontList() {
   NOTIMPLEMENTED();
   return gfx::FontList();
 }
 
 }  // namespace internal
 }  // namespace views