Move more from Window onto Widget.

views/widget/widget.cc

 // Copyright (c) 2011 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 "views/widget/widget.h"
 
 #include "base/logging.h"
 #include "base/message_loop.h"
+#include "base/utf_string_conversions.h"
 #include "ui/gfx/compositor/compositor.h"
 #include "views/focus/view_storage.h"
 #include "views/ime/input_method.h"
 #include "views/views_delegate.h"
 #include "views/widget/default_theme_provider.h"
 #include "views/widget/root_view.h"
 #include "views/widget/native_widget.h"
 #include "views/widget/widget_delegate.h"
 #include "views/window/custom_frame_view.h"
 
@@ skipping 64 matching lines @@
 
 // static
 Widget::InitParams Widget::WindowInitParams() {
   return InitParams(InitParams::TYPE_WINDOW);
 }
 
 Widget::Widget()
     : is_mouse_button_pressed_(false),
       last_mouse_event_was_move_(false),
       native_widget_(NULL),
-      type_(InitParams::TYPE_WINDOW),
       widget_delegate_(NULL),
       non_client_view_(NULL),
       dragged_view_(NULL),
       ownership_(InitParams::NATIVE_WIDGET_OWNS_WIDGET),
       is_secondary_widget_(true),
-      frame_type_(FRAME_TYPE_DEFAULT) {
+      frame_type_(FRAME_TYPE_DEFAULT),
+      disable_inactive_rendering_(false),
+      widget_closed_(false) {
 }
 
 Widget::~Widget() {
   DestroyRootView();
 
   if (ownership_ == InitParams::WIDGET_OWNS_NATIVE_WIDGET)
     delete native_widget_;
 }
 
 // static
 void Widget::SetPureViews(bool pure) {
   use_pure_views = pure;
 }
 
 // static
 bool Widget::IsPureViews() {
   return use_pure_views;
 }
 
 // static
 Widget* Widget::GetWidgetForNativeView(gfx::NativeView native_view) {
   NativeWidget* native_widget =
       NativeWidget::GetNativeWidgetForNativeView(native_view);
   return native_widget ? native_widget->GetWidget() : NULL;
 }
 
 void Widget::Init(const InitParams& params) {
-  type_ = params.type;
   widget_delegate_ =
       params.delegate ? params.delegate : new DefaultWidgetDelegate;
   ownership_ = params.ownership;
   native_widget_ =
       params.native_widget ? params.native_widget
                            : NativeWidget::CreateNativeWidget(this);
   GetRootView();
   default_theme_provider_.reset(new DefaultThemeProvider);
   if (params.type == InitParams::TYPE_MENU)
     is_mouse_button_pressed_ = native_widget_->IsMouseButtonDown();
   native_widget_->InitNativeWidget(params);
-  if (type_ == InitParams::TYPE_WINDOW) {
+  if (params.type == InitParams::TYPE_WINDOW) {
     non_client_view_ = new NonClientView;
     non_client_view_->SetFrameView(CreateNonClientFrameView());
+    // Create the ClientView, add it to the NonClientView and add the
+    // NonClientView to the RootView. This will cause everything to be parented.
+    non_client_view_->set_client_view(widget_delegate_->CreateClientView(this));
+    SetContentsView(non_client_view_);
   }
 }
 
 // Unconverted methods (see header) --------------------------------------------
 
 gfx::NativeView Widget::GetNativeView() const {
    return native_widget_->GetNativeView();
 }
 
 gfx::NativeWindow Widget::GetNativeWindow() const {
@@ skipping 30 matching lines @@
   if (!attached) {
     FocusManager* focus_manager = GetFocusManager();
     // We are being removed from a window hierarchy.  Treat this as
     // the root_view_ being removed.
     if (focus_manager)
       focus_manager->ViewRemoved(root_view_.get());
   }
   root_view_->NotifyNativeViewHierarchyChanged(attached, native_view);
 }
 
+Window* Widget::AsWindow() {
+  return NULL;
+}
+
+const Window* Widget::AsWindow() const {
+  return NULL;
+}
+
 // Converted methods (see header) ----------------------------------------------
 
 Widget* Widget::GetTopLevelWidget() {
   return const_cast<Widget*>(
       const_cast<const Widget*>(this)->GetTopLevelWidget());
 }
 
 const Widget* Widget::GetTopLevelWidget() const {
   NativeWidget* native_widget =
       NativeWidget::GetTopLevelNativeWidget(GetNativeView());
   return native_widget ? native_widget->GetWidget() : NULL;
 }
 
 void Widget::SetContentsView(View* view) {
   root_view_->SetContentsView(view);
 }
 
 gfx::Rect Widget::GetWindowScreenBounds() const {
   return native_widget_->GetWindowScreenBounds();
 }
 
 gfx::Rect Widget::GetClientAreaScreenBounds() const {
   return native_widget_->GetClientAreaScreenBounds();
 }
 
+gfx::Rect Widget::GetRestoredBounds() const {
+  return native_widget_->GetRestoredBounds();
+}
+
 void Widget::SetBounds(const gfx::Rect& bounds) {
   native_widget_->SetBounds(bounds);
 }
 
 void Widget::SetSize(const gfx::Size& size) {
   native_widget_->SetSize(size);
 }
 
 void Widget::SetBoundsConstrained(const gfx::Rect& bounds,
                                   Widget* other_widget) {
   native_widget_->SetBoundsConstrained(bounds, other_widget);
 }
 
 void Widget::MoveAboveWidget(Widget* widget) {
   native_widget_->MoveAbove(widget->GetNativeView());
 }
 
 void Widget::MoveAbove(gfx::NativeView native_view) {
   native_widget_->MoveAbove(native_view);
 }
 
 void Widget::SetShape(gfx::NativeRegion shape) {
   native_widget_->SetShape(shape);
 }
 
 void Widget::Close() {
-  native_widget_->Close();
+  if (widget_closed_) {
+    // It appears we can hit this code path if you close a modal dialog then
+    // close the last browser before the destructor is hit, which triggers
+    // invoking Close again.
+    return;
+  }
+
+  bool can_close = true;
+  if (non_client_view_)
+    can_close = non_client_view_->CanClose();
+  if (can_close) {
+    SaveWindowPosition();
+    native_widget_->Close();
+    widget_closed_ = true;
+  }
 }
 
 void Widget::CloseNow() {
   native_widget_->CloseNow();
 }
 
+void Widget::EnableClose(bool enable) {
+  non_client_view_->EnableClose(enable);
+  native_widget_->EnableClose(enable);
+}
+
 void Widget::Show() {
   native_widget_->Show();
 }
 
 void Widget::Hide() {
   native_widget_->Hide();
 }
 
+void Widget::ShowInactive() {
+  native_widget_->ShowNativeWidget(NativeWidget::SHOW_INACTIVE);
+}
+
 void Widget::Activate() {
   native_widget_->Activate();
 }
 
 void Widget::Deactivate() {
   native_widget_->Deactivate();
 }
 
 bool Widget::IsActive() const {
   return native_widget_->IsActive();
 }
 
+void Widget::DisableInactiveRendering() {
+  disable_inactive_rendering_ = true;
+  non_client_view_->DisableInactiveRendering(disable_inactive_rendering_);
+}
+
 void Widget::SetAlwaysOnTop(bool on_top) {
   native_widget_->SetAlwaysOnTop(on_top);
 }
 
 void Widget::Maximize() {
   native_widget_->Maximize();
 }
 
 void Widget::Minimize() {
   native_widget_->Minimize();
@@ skipping 100 matching lines @@
 }
 
 void Widget::SetCursor(gfx::NativeCursor cursor) {
   native_widget_->SetCursor(cursor);
 }
 
 void Widget::ResetLastMouseMoveFlag() {
   last_mouse_event_was_move_ = false;
 }
 
+void Widget::UpdateWindowTitle() {
+  // If the non-client view is rendering its own title, it'll need to relayout
+  // now.
+  non_client_view_->Layout();
+
+  // Update the native frame's text. We do this regardless of whether or not
+  // the native frame is being used, since this also updates the taskbar, etc.
+  string16 window_title;
+  if (native_widget_->IsScreenReaderActive()) {
+    window_title = WideToUTF16(widget_delegate_->GetAccessibleWindowTitle());
+  } else {
+    window_title = WideToUTF16(widget_delegate_->GetWindowTitle());
+  }
+  base::i18n::AdjustStringForLocaleDirection(&window_title);
+  native_widget_->SetWindowTitle(UTF16ToWide(window_title));
+}
+
+void Widget::UpdateWindowIcon() {
+  non_client_view_->UpdateWindowIcon();
+  native_widget_->SetWindowIcons(widget_delegate_->GetWindowIcon(),
+                                 widget_delegate_->GetWindowAppIcon());
+}
+
 FocusTraversable* Widget::GetFocusTraversable() {
   return static_cast<internal::RootView*>(root_view_.get());
 }
 
 void Widget::ThemeChanged() {
   root_view_->ThemeChanged();
 }
 
 void Widget::LocaleChanged() {
   root_view_->LocaleChanged();
@@ skipping 47 matching lines @@
   if (ViewsDelegate::views_delegate)
     ViewsDelegate::views_delegate->NotifyAccessibilityEvent(view, event_type);
 
   if (send_native_event)
     native_widget_->SendNativeAccessibilityEvent(view, event_type);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Widget, NativeWidgetDelegate implementation:
 
+bool Widget::CanActivate() const {
+  return widget_delegate_->CanActivate();
+}
+
+bool Widget::IsInactiveRenderingDisabled() const {
+  return disable_inactive_rendering_;
+}
+
+void Widget::EnableInactiveRendering() {
+  disable_inactive_rendering_ = false;
+  non_client_view_->DisableInactiveRendering(false);
+}
+
+void Widget::OnNativeWidgetActivationChanged(bool active) {
+  if (!active)
+    SaveWindowPosition();
+
+  // TODO(beng): merge these two.
+  widget_delegate_->OnWidgetActivated(active);
+  widget_delegate_->OnWindowActivationChanged(active);
+}
+
 void Widget::OnNativeFocus(gfx::NativeView focused_view) {
   GetFocusManager()->GetWidgetFocusManager()->OnWidgetFocusEvent(
       focused_view,
       GetNativeView());
 }
 
 void Widget::OnNativeBlur(gfx::NativeView focused_view) {
   GetFocusManager()->GetWidgetFocusManager()->OnWidgetFocusEvent(
       GetNativeView(),
       focused_view);
 }
 
 void Widget::OnNativeWidgetCreated() {
   if (GetTopLevelWidget() == this) {
     // Only the top level Widget in a native widget hierarchy has a focus
     // manager.
     focus_manager_.reset(new FocusManager(this));
   }
   EnsureCompositor();
+
+  native_widget_->SetAccessibleRole(
+      widget_delegate_->GetAccessibleWindowRole());
+  native_widget_->SetAccessibleState(
+      widget_delegate_->GetAccessibleWindowState());
+}
+
+void Widget::OnNativeWidgetDestroying() {
+  if (non_client_view_)
+    non_client_view_->WindowClosing();
+  widget_delegate_->WindowClosing();
 }
 
 void Widget::OnNativeWidgetDestroyed() {
   widget_delegate_->DeleteDelegate();
   widget_delegate_ = NULL;
 }
 
-void Widget::OnSizeChanged(const gfx::Size& new_size) {
+gfx::Size Widget::GetMinimumSize() {
+  return non_client_view_->GetMinimumSize();
+}
+
+void Widget::OnNativeWidgetSizeChanged(const gfx::Size& new_size) {
   root_view_->SetSize(new_size);
 }
 
+void Widget::OnNativeWidgetBeginUserBoundsChange() {
+  widget_delegate_->OnWindowBeginUserBoundsChange();
+}
+
+void Widget::OnNativeWidgetEndUserBoundsChange() {
+  widget_delegate_->OnWindowEndUserBoundsChange();
+}
+
 bool Widget::HasFocusManager() const {
   return !!focus_manager_.get();
 }
 
 bool Widget::OnNativeWidgetPaintAccelerated(const gfx::Rect& dirty_region) {
 #if !defined(COMPOSITOR_2)
   return false;
 #else
   if (!compositor_.get())
     return false;
@@ skipping 10 matching lines @@
   GetRootView()->Paint(canvas);
 #if !defined(COMPOSITOR_2)
   if (compositor_.get()) {
     compositor_->NotifyStart();
     root_view_->PaintComposite(compositor_.get());
     compositor_->NotifyEnd();
   }
 #endif
 }
 
+int Widget::GetNonClientComponent(const gfx::Point& point) {
+  return non_client_view_->NonClientHitTest(point);
+}
+
 bool Widget::OnKeyEvent(const KeyEvent& event) {
   return static_cast<internal::RootView*>(GetRootView())->OnKeyEvent(event);
 }
 
 bool Widget::OnMouseEvent(const MouseEvent& event) {
   switch (event.type()) {
     case ui::ET_MOUSE_PRESSED:
       last_mouse_event_was_move_ = false;
       if (GetRootView()->OnMousePressed(event)) {
         is_mouse_button_pressed_ = true;
@@ skipping 36 matching lines @@
   }
   return true;
 }
 
 void Widget::OnMouseCaptureLost() {
   if (is_mouse_button_pressed_)
     GetRootView()->OnMouseCaptureLost();
   is_mouse_button_pressed_ = false;
 }
 
+bool Widget::ExecuteCommand(int command_id) {
+  return widget_delegate_->ExecuteWindowsCommand(command_id);
+}
+
 Widget* Widget::AsWidget() {
   return this;
 }
 
 const Widget* Widget::AsWidget() const {
   return this;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Widget, FocusTraversable implementation:
@@ skipping 52 matching lines @@
   //            instead of creating a new one here.
   gfx::AcceleratedWidget widget = native_widget_->GetAcceleratedWidget();
   if (widget != gfx::kNullAcceleratedWidget)
     compositor_ = ui::Compositor::Create(widget);
 }
 
 bool Widget::ShouldReleaseCaptureOnMouseReleased() const {
   return true;
 }
 
+void Widget::SaveWindowPosition() {
+  // The window delegate does the actual saving for us. It seems like (judging
+  // by go/crash) that in some circumstances we can end up here after
+  // WM_DESTROY, at which point the window delegate is likely gone. So just
+  // bail.
+  if (!widget_delegate_)
+    return;
+
+  bool maximized;
+  gfx::Rect bounds;
+  native_widget_->GetWindowBoundsAndMaximizedState(&bounds, &maximized);
+  widget_delegate_->SaveWindowPlacement(bounds, maximized);
+}
+
+
+
 }  // namespace views