Move more from Window onto Widget.

views/window/dialog_client_view.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/window/dialog_client_view.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <uxtheme.h>
 #include <vsstyle.h>
 #else
 #include <gtk/gtk.h>
 #endif
 
 #include <algorithm>
 
 #include "base/utf_string_conversions.h"
 #include "grit/app_strings.h"
 #include "ui/base/keycodes/keyboard_codes.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas_skia.h"
 #include "ui/gfx/font.h"
 #include "views/controls/button/native_button.h"
 #include "views/layout/layout_constants.h"
 #include "views/widget/root_view.h"
+#include "views/widget/widget.h"
 #include "views/window/dialog_delegate.h"
-#include "views/window/window.h"
 
 #if defined(OS_WIN)
 #include "ui/gfx/native_theme.h"
 #else
 #include "ui/gfx/skia_utils_gtk.h"
 #include "views/widget/widget.h"
 #include "views/window/hit_test.h"
 #endif
 
 using ui::MessageBoxFlags;
@@ skipping 22 matching lines @@
 #endif
 
 // DialogButton ----------------------------------------------------------------
 
 // DialogButtons is used for the ok/cancel buttons of the window. DialogButton
 // forwards AcceleratorPressed to the delegate.
 
 class DialogButton : public NativeButton {
  public:
   DialogButton(ButtonListener* listener,
-               Window* owner,
+               Widget* owner,
                MessageBoxFlags::DialogButton type,
                const std::wstring& title,
                bool is_default)
       : NativeButton(listener, title),
         owner_(owner),
         type_(type) {
     SetIsDefault(is_default);
   }
 
   // Overridden to forward to the delegate.
   virtual bool AcceleratorPressed(const Accelerator& accelerator) {
-    if (!owner_->window_delegate()->AsDialogDelegate()->
+    if (!owner_->widget_delegate()->AsDialogDelegate()->
         AreAcceleratorsEnabled(type_)) {
       return false;
     }
     return NativeButton::AcceleratorPressed(accelerator);
   }
 
  private:
-  Window* owner_;
+  Widget* owner_;
   const MessageBoxFlags::DialogButton type_;
 
   DISALLOW_COPY_AND_ASSIGN(DialogButton);
 };
 
 }  // namespace
 
 // static
 gfx::Font* DialogClientView::dialog_button_font_ = NULL;
 static const int kDialogMinButtonWidth = 75;
 static const int kDialogButtonLabelSpacing = 16;
 static const int kDialogButtonContentSpacing = 5;
 
 // The group used by the buttons.  This name is chosen voluntarily big not to
 // conflict with other groups that could be in the dialog content.
 static const int kButtonGroup = 6666;
 
 ///////////////////////////////////////////////////////////////////////////////
 // DialogClientView, public:
 
-DialogClientView::DialogClientView(Window* owner, View* contents_view)
+DialogClientView::DialogClientView(Widget* owner, View* contents_view)
     : ClientView(owner, contents_view),
       ok_button_(NULL),
       cancel_button_(NULL),
       default_button_(NULL),
       extra_view_(NULL),
       size_extra_view_height_to_buttons_(false),
       notified_delegate_(false),
       listening_to_focus_(false),
       saved_focus_manager_(NULL),
       bottom_view_(NULL) {
   InitClass();
 }
 
 DialogClientView::~DialogClientView() {
 }
 
 void DialogClientView::ShowDialogButtons() {
   DialogDelegate* dd = GetDialogDelegate();
   int buttons = dd->GetDialogButtons();
   if (buttons & MessageBoxFlags::DIALOGBUTTON_OK && !ok_button_) {
     std::wstring label =
         dd->GetDialogButtonLabel(MessageBoxFlags::DIALOGBUTTON_OK);
     if (label.empty())
       label = UTF16ToWide(l10n_util::GetStringUTF16(IDS_APP_OK));
     bool is_default_button =
         (dd->GetDefaultDialogButton() & MessageBoxFlags::DIALOGBUTTON_OK) != 0;
-    ok_button_ = new DialogButton(this, window(),
+    ok_button_ = new DialogButton(this, GetWidget(),
                                   MessageBoxFlags::DIALOGBUTTON_OK, label,
                                   is_default_button);
     ok_button_->SetGroup(kButtonGroup);
     if (is_default_button)
       default_button_ = ok_button_;
     if (!(buttons & MessageBoxFlags::DIALOGBUTTON_CANCEL))
       ok_button_->AddAccelerator(Accelerator(ui::VKEY_ESCAPE,
                                              false, false, false));
     AddChildView(ok_button_);
   }
   if (buttons & MessageBoxFlags::DIALOGBUTTON_CANCEL && !cancel_button_) {
     std::wstring label =
         dd->GetDialogButtonLabel(MessageBoxFlags::DIALOGBUTTON_CANCEL);
     if (label.empty()) {
       if (buttons & MessageBoxFlags::DIALOGBUTTON_OK) {
         label = UTF16ToWide(l10n_util::GetStringUTF16(IDS_APP_CANCEL));
       } else {
         label = UTF16ToWide(l10n_util::GetStringUTF16(IDS_APP_CLOSE));
       }
     }
     bool is_default_button =
         (dd->GetDefaultDialogButton() & MessageBoxFlags::DIALOGBUTTON_CANCEL)
         != 0;
-    cancel_button_ = new DialogButton(this, window(),
+    cancel_button_ = new DialogButton(this, GetWidget(),
                                       MessageBoxFlags::DIALOGBUTTON_CANCEL,
                                       label, is_default_button);
     cancel_button_->SetGroup(kButtonGroup);
     cancel_button_->AddAccelerator(Accelerator(ui::VKEY_ESCAPE,
                                                false, false, false));
     if (is_default_button)
       default_button_ = ok_button_;
     AddChildView(cancel_button_);
   }
   if (!buttons) {
@@ skipping 103 matching lines @@
   int buttons = dd->GetDialogButtons();
   bool close = true;
   if (buttons & MessageBoxFlags::DIALOGBUTTON_CANCEL)
     close = dd->Cancel();
   else if (buttons & MessageBoxFlags::DIALOGBUTTON_OK)
     close = dd->Accept(true);
   notified_delegate_ = close;
   return close;
 }
 
-void DialogClientView::WindowClosing() {
+void DialogClientView::WidgetClosing() {
   if (listening_to_focus_) {
     DCHECK(saved_focus_manager_);
     if (saved_focus_manager_)
        saved_focus_manager_->RemoveFocusChangeListener(this);
   }
 }
 
 int DialogClientView::NonClientHitTest(const gfx::Point& point) {
   if (size_box_bounds_.Contains(point.x() - x(), point.y() - y()))
     return HTBOTTOMRIGHT;
@@ skipping 16 matching lines @@
     GtkStyle* window_style = gtk_widget_get_style(widget);
     canvas->FillRectInt(gfx::GdkColorToSkColor(
                             window_style->bg[GTK_STATE_NORMAL]),
                         0, 0, width(), height());
   }
 #endif
 }
 
 void DialogClientView::PaintChildren(gfx::Canvas* canvas) {
   View::PaintChildren(canvas);
-  if (!window()->IsMaximized() && !window()->IsMinimized())
+  if (!GetWidget()->IsMaximized() && !GetWidget()->IsMinimized())
     PaintSizeBox(canvas);
 }
 
 void DialogClientView::Layout() {
   if (has_dialog_buttons())
     LayoutDialogButtons();
   if (bottom_view_) {
     gfx::Rect bounds = GetContentsBounds();
     gfx::Size pref = bottom_view_->GetPreferredSize();
     bottom_view_->SetBounds(bounds.x(),
@@ skipping 84 matching lines @@
     CancelWindow();
   } else {
     NOTREACHED();
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // DialogClientView, private:
 
 void DialogClientView::PaintSizeBox(gfx::Canvas* canvas) {
-  if (window()->window_delegate()->CanResize() ||
-      window()->window_delegate()->CanMaximize()) {
+  if (GetWidget()->widget_delegate()->CanResize() ||
+      GetWidget()->widget_delegate()->CanMaximize()) {
 #if defined(OS_WIN)
     gfx::NativeTheme::ExtraParams extra;
     gfx::Size gripper_size = gfx::NativeTheme::instance()->GetPartSize(
         gfx::NativeTheme::kWindowResizeGripper, gfx::NativeTheme::kNormal,
         extra);
 
     // TODO(beng): (http://b/1085509) In "classic" rendering mode, there isn't
     //             a theme-supplied gripper. We should probably improvise
     //             something, which would also require changing |gripper_size|
     //             to have different default values, too...
@@ skipping 91 matching lines @@
   if (extra_view && !extra_view_) {
     extra_view_ = extra_view;
     extra_view_->SetGroup(kButtonGroup);
     AddChildView(extra_view_);
     size_extra_view_height_to_buttons_ =
         GetDialogDelegate()->GetSizeExtraViewHeightToButtons();
   }
 }
 
 DialogDelegate* DialogClientView::GetDialogDelegate() const {
-  return window()->window_delegate()->AsDialogDelegate();
+  return GetWidget()->widget_delegate()->AsDialogDelegate();
 }
 
 void DialogClientView::Close() {
-  window()->Close();
+  GetWidget()->Close();
   GetDialogDelegate()->OnClose();
 }
 
 void DialogClientView::UpdateFocusListener() {
   FocusManager* focus_manager = GetFocusManager();
   // Listen for focus change events so we can update the default button.
   // focus_manager can be NULL when the dialog is created on un-shown view.
   // We start listening for focus changes when the page is visible.
   // Focus manager could also change if window host changes a parent.
   if (listening_to_focus_) {
@@ skipping 16 matching lines @@
 void DialogClientView::InitClass() {
   static bool initialized = false;
   if (!initialized) {
     ResourceBundle& rb = ResourceBundle::GetSharedInstance();
     dialog_button_font_ = new gfx::Font(rb.GetFont(ResourceBundle::BaseFont));
     initialized = true;
   }
 }
 
 }  // namespace views